In attesa di un evento in Java: quanto è difficile?

Question

Ho una discussione che aggiorna il suo stato di tanto in tanto e voglio che un secondo thread sia in grado di aspettare che il primo thread sia fatto. Qualcosa di simile a questo:

Thread 1: 
    while(true) { 
     ...do something... 
     foo.notifyAll() 
     ...wait for some condition that might never happen... 
     ... 
    } 

Thread 2: 
    ... 
    foo.wait(); 
    ... 

Ora, questo sembra bello e tutto meno che Thread 1 di notifyAll() viene eseguito prima attesa Thread 2 di(), in cui Discussione caso 2 attende fino Discussione 1 Notifica nuovo (che potrebbe mai accadere) .

miei possibili soluzioni:

a) potrei usare un CountDownLatch o di un futuro, ma entrambi hanno il problema che essi intrinsecamente eseguito solo una volta . Cioè, nel thread while di Thread 1, avrei bisogno di creare un nuovo foo per aspettare ogni volta e Thread 2 avrebbe bisogno di chiedere quale foo aspettare. Ho una brutta sensazione semplicemente scrivendo

while(true) { 
    foo = new FutureTask(); 
    ... 
    foo.set(...); 
    ...wait for a condition that might never be set... 
    ... 
} 

come temo che a foo = new FutureTask(), cosa succede quando qualcuno attese che il vecchio foo (per "qualche ragione", impostato non è stato chiamato, ad esempio, un bug nella gestione delle eccezioni)?

b) Oppure potrei usare un semaforo:

class Event { 
    Semaphore sem; 
    Event() { sem = new Semaphore(1); sem . } 
    void signal() { sem.release(); } 
    void reset() { sem.acquire(1); } 
    void wait() { if (sem.tryAcquire(1)) { sem.release(); } } 
} 

ma temo che v'è una certa condizione di competizione, se più thread sono wait() ing per esso mentre un altro segnale() s e reset ()S.

Domanda:

non c'è nulla nelle API Java analogo al comportamento degli eventi di Windows? Oppure, se si disprezza Windows, qualcosa come GolG's WaitGroup (cioè un CountDownLatch che consente countUp())? Nulla?

Come fare manualmente:

Thread 2 non può semplicemente aspettare a causa della sveglia spuria e in Java non c'è modo di sapere il motivo per cui Object.wait() ha restituito. Quindi ho bisogno di una variabile di condizione che memorizzi se l'evento è segnalato o meno. Thread 2:

synchronized(foo) { 
    while(!condition) { 
     foo.wait(); 
    } 
} 

E Thread 1 ovviamente imposta condizione su true in un blocco sincronizzato. Grazie a weekens per il suggerimento!

Esiste una classe esistente che include questo comportamento?

Oppure devo copiare e incollare il codice dappertutto?

Answer 1

È prassi normale modificare alcuni stati durante l'esecuzione di notifyAll e controllare alcuni stati durante l'esecuzione di wait().

ad es.

Con questo approccio, non importa se il thread 1 o il thread 2 acquisiscono il blocco prima.

Alcuni strumenti di analisi di codifica ti daranno un avviso se usi la notifica o attendi senza impostare un valore o controllando un valore.

Answer 2

Il modo più semplice è solo per dire

firstThread.join();

Questo sarà il blocco fino alla fine della prima filettatura.

Ma è possibile implementare lo stesso utilizzando attesa/notifica. Sfortunatamente non hai pubblicato i tuoi frammenti di codice reale, ma suppongo che se l'attesa non esce quando chiami notifica, ciò accade perché non hai inserito entrambi nel blocco synchronized. Prestare attenzione che l'argomento "del blocco synchronized deve essere lo stesso per la coppia wait/notify.

Answer 3

È possibile utilizzare un wait() con timeout, nel qual caso non si rischia di attendere per sempre. Si noti inoltre che wait() può tornare anche se non vi è alcuna notifica(), quindi è necessario avvolgere l'attesa in un ciclo condizionato. Questo è il modo standard di aspettare in Java.

synchronized(syncObject) { 
    while(condition.isTrue()) { 
     syncObject.wait(WAIT_TIMEOUT); 
    } 
} 

(nel tuo thread 2)

Edit: Moved sincronizzato al di fuori del ciclo.

Answer 4

Vorrei usare uno BlockingQueue tra i due thread. Utilizzando wait e notify è così 5 minuti fa;)

enum Event { 
    Event, 
    Stop; 
} 

BlockingQueue<Event> queue = new LinkedBlockingQueue<Event>(); 

// Thread 1 
try { 
    while(true) { 
    ...do something... 
    queue.put(Event.Event); 
    ...wait for some condition that might never happen... 
    ... 
    } 
} finally { 
    // Tell other thread we've finished. 
    queue.put(Event.Stop}; 
} 

// Thread 2 
... 
switch (queue.take()) { 
    case Event: 
     ... 
     break; 

    default: 
     ... 
     break; 
}