Java - threads + action

I'm new to Java so I have a simple question that I don't know where to start from - I need to write a function that accepts an Action, at a multi-threads program , and only the first thread that enter the function do the action, and all the other threads wait for him to finish, and then return from the function without doing anything.

As I said - I don't know where to begin because, first - there isn't a static var at the function (static like as in c / c++ ) so how do I make it that only the first thread would start the action, and the others do nothing ? second - for the threads to wait, should I use

public synchronized void lala(Action doThis)
{....}

or should i write something like that inside the function

synchroniz开发者_运维知识库ed (this)
{
...
notify();
}

Thanks !

---

If you want all threads arriving at a method to wait for the first, then they must synchronize on a common object. It could be the same instance (this) on which the methods are invoked, or it could be any other object (an explicit lock object).

If you want to ensure that the first thread is the only one that will perform the action, then you must store this fact somewhere, for all other threads to read, for they will execute the same instructions.

Going by the previous two points, one could lock on this 'fact' variable to achieve the desired outcome

static final AtomicBoolean flag = new AtomicBoolean(false); // synchronize on this, and also store the fact. It is static so that if this is in a Runnable instance will not appear to reset the fact. Don't use the Boolean wrapper, for the value of the flag might be different in certain cases.

public void lala(Action doThis)
{
    synchronized (flag) // synchronize on the flag so that other threads arriving here, will be forced to wait
    {
        if(!flag.get()) // This condition is true only for the first thread.
        {
           doX();
           flag.set(true); //set the flag so that other threads will not invoke doX.
        }
    }
    ...
    doCommonWork();
    ...
}

---

If you're doing threading in any recent version of Java, you really should be using the java.util.concurrent package instead of using Threads directly.

Here's one way you could do it:

private final ExecutorService executor = Executors.newCachedThreadPool();
private final Map<Runnable, Future<?>> submitted 
    = new HashMap<Runnable, Future<?>>();

public void executeOnlyOnce(Runnable action) {
    Future<?> future = null;
    // NOTE: I was tempted to use a ConcurrentHashMap here, but we don't want to
    // get into a possible race with two threads both seeing that a value hasn't
    // been computed yet and both starting a computation, so the synchronized
    // block ensures that no other thread can be submitting the runnable to the
    // executor while we are checking the map.  If, on the other hand, it's not
    // a problem for two threads to both create the same value (that is, this
    // behavior is only intended for caching performance, not for correctness),
    // then it should be safe to use a ConcurrentHashMap and use its
    // putIfAbsent() method instead.
    synchronized(submitted) {
        future = submitted.get(action);
        if(future == null) {
            future = executor.submit(action);
            submitted.put(action, future);
        }
    }
    future.get(); // ignore return value because the runnable returns void
}

Note that this assumes that your Action class (I'm assuming you don't mean javax.swing.Action, right?) implements Runnable and also has a reasonable implementation of equals() and hashCode(). Otherwise, you may need to use a different Map implementation (for example, IdentityHashMap).

Also, this assumes that you may have multiple different actions that you want to execute only once. If that's not the case, then you can drop the Map entirely and do something like this:

private final ExecutorService executor = Executors.newCachedThreadPool();
private final Object lock = new Object();
private volatile Runnable action;
private volatile Future<?> future = null;

public void executeOnlyOnce(Runnable action) {
    synchronized(lock) {
        if(this.action == null) {
            this.action = action;
            this.future = executor.submit(action);
        } else if(!this.action.equals(action)) {
            throw new IllegalArgumentException("Unexpected action");
        }
    }
    future.get();
}

---

public synchronized void foo()
{
 ...
}

is equivalent to

public void foo()
{
     synchronized(this)
     {
          ... 
     }
}

so either of the two options should work. I personally like the synchronized method option.

---

Synchronizing the whole method can sometimes be overkill if there is only a certain part of the code that deals with shared data (for example, a common variable that each thread is updating).

Best approach for performance is to only use the synchronized keyword just around the shared data. If you synchronized the whole method when it is not entirely necessarily then a lot of threads will be waiting when they can still do work within their own local scope.

When a thread enters the synchronize it acquires a lock (if you use the this object it locks on the object itself), the other will wait till the lock-acquiring thread has exited. You actually don't need a notify statement in this situation as the threads will release the lock when they exit the synchronize statement.