Mettre en œuvre une fonction de blocage d'appel en Java

Ce qui est recommandé de /la meilleure façon de mettre en œuvre une fonction de blocage d'appel en Java, qui peut ensuite être débloqué par un appel à partir d'un autre thread?

Fondamentalement, je veux avoir deux méthodes sur un objet, où le premier appel bloque tout thread appelant jusqu'à ce que la deuxième méthode est exécutée par un autre thread:

public class Blocker {

  /* Any thread that calls this function will get blocked */
  public static SomeResultObject blockingCall() {
     //...      
  }

  /* when this function is called all blocked threads will continue */
  public void unblockAll() {
     //...
  }

}

L'intention de la TVA n'est pas juste pour obtenir le blocage de comportement, mais pour écrire une méthode qui bloque jusqu'à ce que le futur quand il est possible de calculer le résultat requis.

OriginalL'auteur mikera | 2011-10-12

  1. 13

    Vous pouvez utiliser un CountDownLatch.

    latch = new CountDownLatch(1);

    À bloc, composez le:

    latch.await();

    Pour le débloquer, composez le:

    latch.countDown();

    OriginalL'auteur Simon Nickerson

  2. 3

    Si vous êtes en attente sur un objet spécifique, vous pouvez appeler myObject.wait() avec un fil, et puis le réveil avec myObject.notify() ou myObject.notifyAll(). Vous devrez peut-être à l'intérieur d'un synchronized bloc:

    class Example {

    List list = new ArrayList();

    //Wait for the list to have an item and return it
    public Object getFromList() {
        synchronized(list) {
            //Do this inside a while loop -- wait() is
            //not guaranteed to only return if the condition
            //is satisfied -- it can return any time
            while(list.empty()) {
                //Wait until list.notify() is called
                //Note: The lock will be released until
                //      this call returns.
                list.wait();
            }
            return list.remove(0);
        }
    }

    //Add an object to the list and wake up
    //anyone waiting
    public void addToList(Object item) {
        synchronized(list) {
            list.add(item);
            //Wake up anything blocking on list.wait() 
            //Note that we know that only one waiting
            //call can complete (since we only added one
            //item to process. If we wanted to wake them
            //all up, we'd use list.notifyAll()
            list.notify();
        }
    }
}
    Pas sûr que je serais partisan d'wait() et notify() dans le nouveau code - ils sont difficiles à obtenir le droit. (Par exemple, dans votre extrait de code, il est probablement plus sûr d'utiliser notifyAll() que notify()). Voir Joshua Bloch "Effective Java" l'article 69.
    aussi, il existe de nouvelles alternatives (ReentrantLock#newCondition avec des méthodes await() et signalAll()) qui doit décourager l'usage de l'archaïque wait/notify.

    OriginalL'auteur Brendan Long

  3. 2

    Il ya un couple de différentes approches et les primitives disponibles, mais les sons les plus appropriés comme un CyclicBarrier ou un CountDownLatch.

    OriginalL'auteur Brian Kelly