Pourquoi faut-il attendre() toujours être synchronisé bloc

Nous savons tous que pour invoquer de l'Objet.wait(), cet appel doit être placé dans synchronisé bloc, sinon un IllegalMonitorStateException est levée. Mais quelle est la raison de cette restriction? Je sais que wait() communiqués de le surveiller, mais pourquoi avons-nous besoin explicitement acquérir le moniteur en faisant notamment le bloc synchronisé, puis relâchez-le moniteur en appelant wait()?

Quel est le potentiel de dégâts si il était possible d'invoquer wait() à l'extérieur d'un bloc synchronisé, en conservant c'est de la sémantique - la suspension de l'appelant fil?

InformationsquelleAutor diy | 2010-05-06

225

Un wait() n'a de sens que lorsqu'il y a également un notify(), il est donc toujours au sujet de la communication entre les threads, et que les besoins de synchronisation pour fonctionner correctement. On pourrait arguer que ce devrait être implicite, mais qui ne serait pas vraiment aider, pour la raison suivante:

Sémantiquement, vous n'avez jamais juste wait(). Vous avez besoin d'une condition à satsified, et si c'est non, vous attendez jusqu'à ce qu'il est. Donc, ce que vous avez vraiment à faire est de
```
if(!condition){
    wait();
}
```
Mais la condition est définie par un thread séparé, afin d'avoir ce travail correctement vous avez besoin de synchronisation.

Quelques choses de mal avec elle, où tout simplement parce que votre fil de quitter l'attente ne veut pas dire la condition que vous êtes à la recherche pour les est vrai:
- Vous pouvez obtenir de fausses réveils (ce qui signifie qu'un thread peut réveiller d'attente sans avoir jamais reçu une notification), ou
- La condition peut obtenir le jeu, mais un thread troisième sorte que la condition faux à nouveau par le temps le thread en attente se réveille (et rachète le moniteur).
Pour faire face à ces cas, ce que vous avez vraiment besoin est toujours une variante de ceci:
```
synchronized(lock){
    while(!condition){
        lock.wait();
    }
}
```
Mieux encore, ne plaisante pas avec les primitives de synchronisation à tous et à travailler avec les abstractions proposées dans le java.util.concurrent paquets.
- Il y a une discussion détaillée ici aussi, dire essentiellement la même chose. coding.derkeiler.com/Archive/Java/comp.lang.java.programmer/...
- btw, si vous n'êtes pas à ignorer interrompu drapeau de la boucle est de vérifier les Thread.interrupted() ainsi.
- Je peux encore faire quelque chose comme: while(!condition){synchronized(this){wait();}} ce qui signifie qu'il y a toujours une course entre la vérification de l'état et de l'attente, même si wait() est correctement appelé dans un bloc synchronisé. Si il ya une autre raison derrière cette restriction, peut-être en raison de la façon dont il est mis en œuvre en Java?
- Bonne réponse! Petit point: les réveils intempestifs venir de l'OS sous-jacent et ne sont pas déclenchées par un notify() (et donc pas de troisième thread en question). Fausse interruptions sur Wikipedia , lecture Intéressante sur pourquoi ils existent
- Un autre mauvais scénario: la condition est fausse, nous sommes sur le point d'aller à wait() et puis un autre thread changements de l'état et appelle notify(). Parce que nous ne sommes pas en attendre() et pourtant, il va nous manquer ce notify(). En d'autres termes, de test et d'attendre, ainsi que de modifier et d'informer doit être atomique.
- Dans votre exemple n'est-il pas nécessaire d'avoir de la variable de condition changement également dans synchronized bloc? Je veux dire changer de condition variable doit être atomique droit?
- Si c'est un type qui peut être écrit de manière atomique (tels que le booléen tacite par de l'utiliser directement dans une si la clause) et il n'y a pas d'interdépendance avec d'autres données partagées, vous pourriez vous en sortir avec la déclarant volatile. Mais vous avez besoin de ça ou de synchronisation pour s'assurer que la mise à jour sera visible par les autres threads rapidement.
InformationsquelleAutor Michael Borgwardt
274

Quel est le potentiel de dégâts si il était possible d'invoquer wait() à l'extérieur d'un bloc synchronisé, en conservant c'est de la sémantique - la suspension de l'appelant fil?

Illustrons les questions que nous serions confrontés à de si wait() pourraient être appelées à l'extérieur d'un bloc synchronisé avec un exemple concret.

Supposons que nous avons à mettre en œuvre un blocage de la file d'attente (je sais, il y a déjà une dans l'API 🙂

Une première tentative (sans synchronisation) pourrait ressembler à quelque chose le long des lignes ci-dessous
```
class BlockingQueue {
    Queue<String> buffer = new LinkedList<String>();

    public void give(String data) {
        buffer.add(data);
        notify();                   //Since someone may be waiting in take!
    }

    public String take() throws InterruptedException {
        while (buffer.isEmpty())    //don't use "if" due to spurious wakeups.
            wait();
        return buffer.remove();
    }
}
```
C'est ce qui pourrait éventuellement arriver:
1. Un thread consommateur appels take() et voit que le buffer.isEmpty().
2. Avant que le thread consommateur fait appel wait(), un producteur de fil vient le long et appelle un plein give(), qui est, buffer.add(data); notify();
3. Le thread consommateur fera alors appel à wait() (et miss la notify() qui vient d'être appelé).
4. Si malchanceux, le producteur thread ne produira pas plus give() comme un résultat du fait que le thread consommateur ne se réveille jamais, et nous avons une impasse.
Une fois que vous comprenez le problème, la solution est évidente: Utiliser synchronized pour s'assurer notify n'est jamais appelé entre isEmpty et wait.

Sans entrer dans les détails: Ce problème de synchronisation est universelle. Comme Michael Borgwardt souligne, wait/notify est tout au sujet de la communication entre les threads, de sorte que vous aurez toujours une condition de course similaire à celle décrite ci-dessus. C'est pourquoi la "plus qu'à attendre à l'intérieur synchronisée", la règle est appliquée.

Un paragraphe de la lien posté par @Willie résume assez bien:

Vous avez besoin d'une garantie absolue que le serveur et le déclarant d'accord sur l'état du prédicat. Le serveur vérifie l'état du prédicat à un certain point légèrement AVANT qu'il aille dormir, mais cela dépend de la justesse sur le prédicat vrai LORSQU'il s'endort. Il y a une période de vulnérabilité entre ces deux événements, ce qui peut rompre le programme.

Le prédicat que le producteur et le consommateur à convenir est dans l'exemple ci-dessus buffer.isEmpty(). Et le contrat est résolu en veillant à ce que l'attente et à notifier sont effectuées dans synchronized blocs.

Ce message a été réécrit comme un article ici: Java: Pourquoi attendre doit être appelée dans un bloc synchronisé
- En outre, assurez-vous que les modifications apportées à l'état est vu immédiatement après le wait() se termine, je suppose. Sinon, également à une impasse depuis le notify() a déjà été appelé.
- Intéressant, mais notez que l'appel synchronisé en fait ne permet pas toujours de résoudre de tels problèmes en raison de la "non fiables" la nature de wait() et notify(). Lire la suite ici: stackoverflow.com/questions/21439355/.... La raison pour laquelle de synchronisation est nécessaire fixe au sein de l'architecture matérielle (voir ma réponse ci-dessous).
- mais si ajouter return buffer.remove(); en tout en bloc, mais après wait();, ça marche?
- non, le fil peut être réveillé pour d'autres raisons que quelqu'un appeler, donner. En d'autres termes, le tampon peut être vide, même après wait retourne.
- J'ai seulement Thread.currentThread().wait(); dans le main fonction entouré par un try-catch pour InterruptedException. Sans synchronized bloc, il me donne la même exception IllegalMonitorStateException. Ce qui le rend atteindre d'état illégales maintenant? Il fonctionne à l'intérieur de synchronized bloc bien.
- ne fait pas de sens. Vous voudrez probablement ajouter un Object lock = new Object(); champ dans votre classe, et ne lock.wait(); (ou quelque chose de similaire). Je n'ai jamais vu personne d'appel wait() sur un Thread objet.
- Il n'est pas sur la Thread objet bu la java main fonction. Je comprends que ça n'a pas de sens. Mais pourquoi donne-t-il exception? Ce qui se passe exactement à l'intérieur de wait?
- synchronized fait en sorte de vous-même que moniteur. Vous pouvez uniquement appeler wait sur les moniteurs que vous possédez. Voir la javadoc pour attendre: "Le thread courant doit être propriétaire de cet objet à l'écran."
- Ainsi, il sera mieux si Java permet de s'assurer que la condition+wait/notify est à l'intérieur de la synchronized de la méthode/de bloc. Mais au moins, il applique pour wait() et notify(), droit? Est-il une situation où l'état peut être mis à l'extérieur synchronized et seulement wait et notify à l'intérieur?
- Mais au moins, il s'applique pour le wait() et notify(), non? C'est vrai. Je ne peux pas penser à une situation où l'état peut être mis à l'extérieur synchronisé. Ce serait une situation où l'évaluation de la condition n'a pas vraiment d'importance à l'endroit où attendre ou notification est appelé.
- effectuer donner/avertir et isEmpty/attendre atomiquement" - c'est vrai qu'il doit y avoir un ordre total entre tous les notify et checkCondition&wait actions, et c'est obtenue par l'exécution notify et checkCondition&wait dans synchronisé blocs. Mais il n'y a pas de raison de universellement besoin d'un ordre total entre setConditionToTrue&notify et checkCondition&wait actions, donc il n'y a pas de raison de universellement besoin de mettre setConditionToTrue et notify dans un bloc synchronisé. Êtes-vous d'accord?
- oui, merci de le signaler. J'ai mis à jour la réponse.
InformationsquelleAutor aioobe
12

@Rollerball est droit. Le wait() est appelé, de sorte que le fil peut attendre une condition pour se produire lors de cette wait() appel arrive, le fil est forcé d'abandonner sa serrure.

Renoncer à quelque chose, il faut d'abord. Thread doit posséder la fermeture.
D'où la nécessité d'appeler à l'intérieur d'un synchronized de la méthode/de bloc.

Oui, je suis d'accord avec toutes les réponses ci-dessus concernant les dommages potentiels/incohérences si vous n'avez pas de vérifier l'état au sein de synchronized de la méthode/de bloc. Cependant, comme @shrini1000 a souligné, à juste appeler wait() dans synchronisé bloc ne sera pas éviter cette incohérence de passe.

Voici une belle lecture..
- Expliquer "correctement" correctement. Votre commentaire est d'aucune utilité pour personne.
InformationsquelleAutor ashoka.devanampriya
4

Le problème, il peut causer si vous ne pas synchroniser avant de wait() est comme suit:
1. Si le 1er thread entre dans makeChangeOnX() et vérifie la condition du while, et il est true (x.metCondition() retourne false, signifie x.condition est false) ainsi il sera à l'intérieur. Puis juste avant la wait() méthode, un autre thread va à setConditionToTrue() et définit la x.condition à true et notifyAll().
2. Seulement après que, le 1er thread va entrer dans sa wait() méthode (pas affectée par la notifyAll() qui s'est passé quelques instants avant).
  Dans ce cas, le 1er thread va rester en attente pour un autre thread pour effectuer setConditionToTrue(), mais ça pourrait ne pas se produire à nouveau.
Mais si vous mettez synchronized avant les méthodes qui modifient l'état de l'objet, cela ne se produira pas.
```
class A {

    private Object X;

    makeChangeOnX(){
        while (! x.getCondition()){
            wait();
            }
        //Do the change
    }

    setConditionToTrue(){
        x.condition = true; 
        notifyAll();

    }
    setConditionToFalse(){
        x.condition = false;
        notifyAll();
    }
    bool getCondition(){
        return x.condition;
    }
}
```
InformationsquelleAutor Shay.G
2

Nous savons tous que le wait(), notify() et notifyAll() sont les méthodes utilisées pour l'inter-thread
les communications. Pour se débarrasser de manquer de signal et de fausse réveil problèmes, thread en attente
attend toujours en fonction de certaines conditions.
par exemple-
```
boolean wasNotified = false;
while(!wasNotified) {
    wait();
}
```
Puis avisant ensembles de fil wasNotified variable à true et informer.

Chaque thread a son cache local donc tous les changements de la première à obtenir écrite, il y a et
ensuite promu à la mémoire principale progressivement.

Eu ces méthodes qui n'ont pas invoqué dans synchronisé bloc, le wasNotified variable
ne serait pas être évacuées dans la mémoire principale et la serait dans le thread du cache local
si le thread en attente gardera attendant le signal du bien qu'il a été réinitialisé par une notification
fil de discussion.

Pour résoudre ces types de problèmes, ces méthodes sont toujours appelées à l'intérieur de bloc synchronisé
qui assure que lors d'une synchronisation de bloc commence alors tout sera lu à partir des principaux
mémoire et sera injectée dans la mémoire principale avant de quitter le bloc synchronisé.
```
synchronized(monitor) {
    boolean wasNotified = false;
    while(!wasNotified) {
        wait();
    }
}
```
Merci, j'espère qu'elle précise.

InformationsquelleAutor Aavesh Yadav
0

directement à partir de cette java oracle tutoriel:

Lorsqu'un thread appelle d.attendez, il doit posséder la intrinsèques de verrouillage pour le d —
sinon, une erreur est levée. Invoquant l'attendre à l'intérieur d'un synchronisé
la méthode est un moyen simple d'acquérir la valeur intrinsèque de verrouillage.
- Les OP le savais déjà. La question est: "Pourquoi?"
- À partir de la question à laquelle l'auteur fait, ne semble pas que l'auteur de la question a une compréhension claire de ce que j'ai cité le tutoriel.Et de plus, ma réponse, explique "Pourquoi".
- 'Sinon, une erreur est levée" n'est pas vraiment "pourquoi".
InformationsquelleAutor Rollerball
0

En fait cela a à voir avec l'architecture matérielle (c'est à dire RAM et caches).

Si vous n'utilisez pas synchronized avec wait() ou notify(), un autre thread pourrait entrer dans le même bloc au lieu d'attendre pour le moniteur d'y entrer. En outre, lors de l'accès à un tableau sans en parallèle, un bloc, un autre thread ne peut pas voir le changement pour elle...en fait un autre thread ne voir toute les changements à quand il a déjà une copie du tableau dans le x-mémoire cache de niveau (un.k.un. 1ère/2ème/3ème niveau caches) de la manipulation du fil de cœur de PROCESSEUR.

Mais synchronisé blocs sont d'un seul côté de la médaille: Si vous avez réellement accéder à un objet à l'intérieur d'un synchronisé contexte de non-synchronisé contexte, l'objet continueront de ne pas être synchronisés au sein d'un même bloc synchronisé, car il contient une copie de l'objet dans son cache. J'ai écrit à ce sujet de questions se posent ici: https://stackoverflow.com/a/21462631 et Lorsqu'un verrou est titulaire d'un non-objet final, la référence de l'objet encore être changé par un autre thread?

En outre, je suis convaincu que le x-niveau caches sont responsables pour la plupart des non-reproductible des erreurs d'exécution. C'est parce que les développeurs ne font généralement pas de savoir le faible niveau de stuff, comme l'utilisation de l'UC de travail ou de la façon dont la hiérarchie de mémoire affecte le fonctionnement d'applications: http://en.wikipedia.org/wiki/Memory_hierarchy

Il reste une énigme pourquoi la programmation des classes ne commencent pas avec la hiérarchie de mémoire et de PROCESSEUR d'architecture de la première. "Bonjour le monde" ne va pas aider ici. 😉
- Viens de découvrir un site qui l'explique parfaitement et en profondeur: javamex.com/tutorials/...
- Hmm.. pas sûr que j'ai suivi. Si la mise en cache a été la seule raison de mettre d'attendre et de notifier à l'intérieur synchronisée, pourquoi n'est-ce pas la synchronisation de mettre à l'intérieur de la mise en œuvre de wait / notify?
- Bonne question, depuis wait / notify pourrait très bien être synchronisé méthodes...peut-être du Soleil d'anciens développeurs Java connaître la réponse? Regardez dans le lien ci-dessus, ou peut-être que ce sera également vous aider: docs.oracle.com/javase/specs/jls/se7/html/jls-17.html
- Une raison pourrait être: Dans les premiers jours de Java il n'y avait pas d'erreurs de compilation lors de l'appelant ne pas synchronisé avant de faire ces multithreading opérations. Au lieu de cela il n'y avait que des erreurs d'exécution (par exemple, coderanch.com/t/239491/java-programmer-SCJP/certification/...). Peut-être ils ont vraiment pensé à @SOLEIL que lorsque les programmeurs de ces erreurs, ils sont contactés, ce qui peut avoir donné l'occasion de vendre plus de leurs serveurs. Quand at-elle changer? Peut-être Java 5.0 ou 6.0, mais en réalité, je ne me souviens pas, pour être honnête...
- TBH je vois quelques problèmes avec votre réponse 1) Votre deuxième phrase n'a aucun sens: Il n'a pas d'importance que objet un thread a un verrou sur. Peu importe ce que l'objet de deux threads synchroniser, tous changements sont visibles. 2) Vous dites un autre thread "ne sera pas" voir tous les changements. Cela devrait être "ne peut pas". 3) je ne sais pas pourquoi vous élevez 1ère/2ème/3ème niveau caches... Ce qui importe, c'est ce que la Mémoire Java Modèle dit et qui est spécifié dans JLS. Alors que l'architecture matérielle peut aider dans la compréhension de pourquoi JLS dit ce qu'il fait, c'est à proprement parler pas pertinent dans ce contexte.
- Vos commentaires sont un peu confus, trop. Il est toujours pas d'erreur de compilation pour appeler wait/notify à l'extérieur d'un bloc synchronisé. Cela a toujours été le cas et n'a pas changé dans la version 5.0 ou 6.0. (Juger si c'est le cas dans un environnement statique est même indécidable!) Le fait que vous ne comprenez pas pourquoi la synchronisation ne peut pas être fait à l'intérieur wait/notify semble indiquer que vous ne comprenez pas pourquoi wait/notify ne doit être appelé lors de la tenue de la serrure dans la première place. Je pense que mon et Michael Borgwardt réponses expliquer assez bien si vous êtes curieux de connaître la raison sous-jacente.
- Je ne sais pas ce que tu veux dire depuis que je suis ces erreurs de compilation lors de l'appel d'attendre à l'extérieur de la synchronisation de bloc...aussi je suis en désaccord avec vous sur la serrure: docs.oracle.com/javase/tutorial/essential/concurrency/... et mes liens ci-dessus-dire un verrou sur l'objet, donc de la synchronisation de l'état de l'objet avec la mémoire principale (mais pas la synchronisation de tous les objets entre tous les threads en attente). Merci de ne pas dire que je suis incompréhension des choses quand j'ai des sources qui prouvent mes mots alors que vous ne publiez pas n'importe quelle source encore, merci (Et oui, je suis en attente de vos liens, sources...).
- Et oui, je sais que vous êtes probablement en référence à Doug Lea lorsqu'il écrit (gee.cs.oswego.edu/dl/cpj/jmm.html): "Un thread d'écriture libère un verrou de synchronisation et un thread de lecture acquiert par la suite que même verrou de synchronisation. En essence, la libération d'un verrou de forces d'une quinte de toutes les écritures de la mémoire de travail employées par le fil, et l'acquisition d'un verrou de forces d'une (re)charger des valeurs accessibles de domaines. Tout bloquer des actions de fournir à l'exclusion uniquement pour les opérations effectuées au sein d'une méthode synchronisée ou en bloc, ces effets de mémoire sont définies de façon à couvrir tous les champs utilisés par le thread...
- ...l'exécution de l'action." Evidemment, il y a quelques problèmes avec ces formulations. Parce qu'il n'est pas clair quels champs de l'objet qu'il veut dire: Le trou du fil champs ou tout simplement tous les objets dans le bloc synchronisé? Eh bien, celui-ci semble être vrai, mais nous ne pouvons pas être sûr que ce que disent les autres: stackoverflow.com/a/1863612/2012947 et stackoverflow.com/a/3601646/2012947 (à noter que Doug est juste un gars tout peut être tout à fait tort, je ne voudrais pas compter uniquement sur lui...et à mon humble avis, si quelqu'un n'est pas d'expliquer quelque chose de clairement qu'il ne comprend pas trop bien!)
- Mais pour répondre à vos points en détail: 1) j'ai écrit "un autre thread maintenant le même objet ne PEUT pas voir les changements que vous faites", ce qui est correct. 2) j'ai dit "non pas [...] QUAND"...vous devez lire le trou de la phrase. 3) Quelle est la Java du Modèle de Mémoire est dit et ce qui est réellement mis en œuvre sont de deux chaussures différentes. Voir mes trois commentaires juste au-dessus. J'aime aussi cet article d'un gars disant que "rinçage" est faux et que c'est juste "l'escrime": mécanique-de la sympathie.blogspot.ch/2013/02/.... Même si Doug Lea est faux...on peut dire qu'une seule chose: ne Jamais être trop sûr.
- Ce que les erreurs de compilation que vous obtenez? Pourriez-vous s'il vous plaît poster un bout de code qui vous donne une erreur de compilation en raison de devoir attendre ou de notifier à l'extérieur d'un bloc synchronisé? (Soit en commentaire ou sur par exemple pastebin.com.)
- Simplement une "Invocation d'Objet.attendre à l'extérieur synchronisé contexte"d'erreur", et le code est juste wait() ou wait(integer) quelque part dans un run() méthode. Btw, je suis à l'aide de NetBeans IDE (7.2)...ce qui me permet d'écrire du code plusieurs fois plus rapide que dans Eclipse et sans aucune absurdité de messages d'erreur. 😉 Oh, btw, je dois vous remercier pour vos remarques, parce qu'il m'a gardé à la réflexion sur le trou synchronisé choses une fois de plus et plus en profondeur, et je dois avouer que je que partiellement compris ce qui se passait réellement (je ne dis pas que mon point de vue de la JVM étaient complètement fausses, mais en partie!). Qui enfin...
- ...conduire à la fameuse question: stackoverflow.com/questions/31052406/.... Sur laquelle certaines personnes avec de nombreux k est fondamentalement admettre qu'ils ont également ne pas comprendre comment la machine fonctionne vraiment, comme je n'avais pas avant. Mais en raison de l'extrême fou et inpolite réactions à cette question, et parce que ne pas le supprimer, même à ma demande (!), J'ai maintenant choisi de ne pas mettre à jour tous mes autres partiellement de mauvaises réponses. En fait, je vais être en hibernation mon compte ici sur SI, et seulement si cette question est complètement enlevé, je suis en train de penser...
- ...de revenir et de corriger toutes mes réponses concernant la synchronisation de la matière. Parler en termes de transitivité, il s'agissait essentiellement de votre post ici que d'une certaine façon "coups de pied" me sortir de cette plattform. J'espère que vous pourrez l'accepter. Good bye, Marcus
- Le "exécuter l'Objet.attendre à l'extérieur synchronisé contexte" est un NetBeans message spécifique et non pas quelque chose qui est mandaté par JLS. Comme pour mes remarques, vous êtes les bienvenus. Aider les autres améliore mon knoledge trop. Comme je l'ai apprendre de nouvelles choses, j'essaie de mettre à jour mes messages. Je vous recommande d'en faire autant. Si vous apprenez que votre réponse est incorrecte, mais n'ont pas le temps de le mettre à jour, elle envisager de le retirer pour éviter de propager la confusion. Enfin, l'un des coups de pied, mais si vous ne supportez pas la chaleur, sortez de la cuisine 😉
- Que la mémoire de la hiérarchie n'a rien à voir avec cela, c'est un mythe. Google "protocole MESI".
InformationsquelleAutor Marcus
0

Lorsque vous appelez notify() d'un objet t, java notifie un particulier t.wait() de la méthode. Mais, comment se fait la java de recherche et de notifier un particulier attendre méthode.

java ne regarde dans le synchronisée bloc de code qui a été verrouillé par t objet. java ne permet pas de rechercher l'ensemble du code de notifier un particulier t.wait().

InformationsquelleAutor lakshman reddy
0

comme par docs:

Le thread courant doit être propriétaire de cet objet à l'écran. Le thread libère
la propriété de ce moniteur.

wait() méthode signifie simplement qu'il libère le verrou sur l'objet. Si l'objet est verrouillé uniquement dans le bloc synchronisé/méthode. Si le thread est en dehors de la synchronisation de bloc signifie qu'il n'est pas verrouillé, si elle n'est pas verrouillé, que feriez-vous communiqué sur l'objet?

InformationsquelleAutor Arun Raaj

Vous devez vous connecter pour publier un commentaire.