Comment utiliser les attendre et de les informer en Java sans IllegalMonitorStateException?

Tout en utilisant le wait et notify ou notifyAll méthodes en Java, les éléments suivants doivent être rappelés:

1. Utilisation notifyAll au lieu de notify si vous vous attendez à ce que plus d'un thread attente d'un verrou.
2. Le attendre et notify méthodes doit être appelée dans un contexte synchronisé. Voir le lien pour une explication plus détaillée.
3. Toujours faire appel à la wait() méthode dans une boucle car si plusieurs threads sont en attente d'un verrou, et l'un d'entre eux a obtenu la serrure et de réinitialiser la condition, alors les autres threads besoin de vérifier l'état après leur réveil pour voir si elles doivent attendre encore ou pouvez commencer le traitement.
4. Utiliser le même objet pour appeler wait() et notify() méthode; chaque objet a son propre cadenas afin de l'appelant wait() sur l'objet A et notify() sur l'objet B n'a aucun sens.

Disons que vous avez de "boîte noire" de l'application avec une certaine classe nommée BlackBoxClass qui a la méthode doSomething();.

En outre, vous avez de l'observateur ou de l'auditeur nommé onResponse(String resp) qui sera appelé par BlackBoxClass après un temps inconnu.

Le flux est simple:

private String mResponse = null; 
...
BlackBoxClass bbc = new BlackBoxClass();
bbc.doSomething();
...
@override
public void onResponse(String resp){        
mResponse = resp;       
}

Permet de dire que nous ne savons pas ce qui se passe avec BlackBoxClass et quand nous devons obtenir de réponse, mais vous ne souhaitez pas poursuivre votre code jusqu'à ce que vous obtenir une réponse ou en d'autres mots obtenir onResponse appel. Ici entre "Synchroniser helper":

public class SyncronizeObj {
public void doWait(long l){
synchronized(this){
try {
this.wait(l);
} catch(InterruptedException e) {
}
}
}
public void doNotify() {
synchronized(this) {
this.notify();
}
}
public void doWait() {
synchronized(this){
try {
this.wait();
} catch(InterruptedException e) {
}
}
}
}

Maintenant, nous pouvons mettre en œuvre ce que nous voulons:

public class Demo {
private String mResponse = null; 
...
SyncronizeObj sync = new SyncronizeObj();
public void impl(){
BlackBoxClass bbc = new BlackBoxClass();
bbc.doSomething();
if(mResponse == null){
sync.doWait();
}
/** at this momoent you sure that you got response from  BlackBoxClass because
onResponse method released your 'wait'. In other cases if you don't want wait too      
long (for example wait data from socket) you can use doWait(time) 
*/ 
...
}
@override
public void onResponse(String resp){        
mResponse = resp;
sync.doNotify();       
}
}

notify() doit être synchronisé ainsi

nous pouvons appeler notifier à reprendre l'exécution de l'attente des objets comme

public synchronized void guardedJoy() {
//This guard only loops once for each special event, which may not
//be the event we're waiting for.
while(!joy) {
try {
wait();
} catch (InterruptedException e) {}
}
System.out.println("Joy and efficiency have been achieved!");
}

reprendre ce en invoquant informer sur un autre objet de même classe

public synchronized notifyJoy() {
joy = true;
notifyAll();
}

Pour ce problème particulier, pourquoi ne pas stocker vos différents résultats dans des variables, puis lorsque le dernier de votre fil est traitée, vous pouvez imprimer dans le format que vous souhaitez. Ceci est particulièrement utile si vous êtes va être à l'aide de vos antécédents de travail dans d'autres projets.

Vous avez gardé votre bloc de code lorsque vous appelez wait(), en utilisant la méthode synchronized(this).

Mais vous n'avez pas pris les mêmes précautions lorsque vous appelez notify() méthode sans utiliser gardé bloc : synchronized(this) ou synchronized(someObject)

Si vous vous référez à la documentation oracle page sur Objet classe, qui contient wait() ,notify(), notifyAll() méthodes, vous pouvez voir ci-dessous la précaution dans l'ensemble de ces trois méthodes

Cette méthode ne doit être appelée que par un thread qui est le propriétaire de cet objet du moniteur

Beaucoup de choses ont été modifiées au cours des 7 dernières années et voyons dans d'autres solutions de rechange à synchronized ci-dessous SE questions:

Pourquoi utiliser un ReentrantLock si on peut l'utiliser synchronisée(ce)?

La synchronisation vs Verrouillage

Éviter synchronisée(ce) en Java?