Implementieren Sie einen blockierenden Funktionsaufruf in Java

Was ist die empfohlene /beste Weg, um zu implementieren ein blockierender Funktionsaufruf in Java, das kann später aufgehoben durch einen Aufruf aus einem anderen thread?

Grundsätzlich möchte ich zwei Methoden auf ein Objekt, wo der erste Anruf blockiert aufrufenden thread, bis die zweite Methode wird von einem anderen 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() {
     //...
  }

}

Die Absicht ist ÜBRIGENDS nicht nur um blockieren von Verhalten, sondern schreiben eine Methode, die Blöcke, bis irgendwann, wenn es möglich ist, zu berechnen, das gewünschte Ergebnis.

InformationsquelleAutor mikera | 2011-10-12
  1. 13

    Können Sie eine CountDownLatch.

    latch = new CountDownLatch(1);

    Blockieren, rufen Sie:

    latch.await();

    Wieder zu entsperren, rufen Sie:

    latch.countDown();
    InformationsquelleAutor Simon Nickerson
  2. 3

    Wenn Sie warten auf ein bestimmtes Objekt, rufen Sie myObject.wait() mit einem thread, und dann Sie aufwachen mit myObject.notify() oder myObject.notifyAll(). Es kann notwendig sein, innerhalb einer synchronized block:

    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();
        }
    }
}
    • Nicht sicher, ich würde es befürworten wait() und notify() in der neuen code - Sie sind schwierig zu bekommen Recht. (Zum Beispiel, in Ihr code-snippet, es ist wohl sicherer, zu verwenden, notifyAll() als notify()). Siehe Joshua Bloch ' s "Effective Java" item 69.
    • auch gibt es neuere alternativen (ReentrantLock#newCondition mit Methoden await() und signalAll()) das würde abschrecken sollten die Verwendung von archaischen wait/notify.
    InformationsquelleAutor Brendan Long
  3. 2

    Gibt es ein paar unterschiedliche Ansätze und Grundformen zur Verfügung, aber die entsprechenden sounds, die wie ein CyclicBarrier oder eine CountDownLatch.

    InformationsquelleAutor Brian Kelly
Schreibe einen Kommentar