java.lang.IllegalMonitorStateException: (m=null) n'a pas réussi à obtenir moniteur pour

Pourquoi cela se produit? Le truc, c'est que le moniteur de l'objet n'est pas nulle, mais encore nous obtenir cette exception assez souvent:

java.lang.IllegalMonitorStateException: (m=null) Failed to get monitor for (tIdx=60)
        at java.lang.Object.wait(Object.java:474)
        at ...

Le code qui la provoque, c'est une simple piscine solution:

    public Object takeObject() {
        Object obj = internalTakeObject();
        while (obj == null) {
            try {
                available.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            obj = internalTakeObject();
        }
        return obj;
    }

    private Object internalTakeObject() {
        Object obj = null;
        synchronized (available) {
            if (available.size() > 0) {
                obj = available.keySet().iterator().next();
                available.remove(obj);
                synchronized (taken) {
                    taken.put(obj, Boolean.valueOf(true));
                }
            }
        }
        return obj;
    }

    public void returnObject(Object obj) {
        synchronized (taken) {
            taken.remove(obj);
        }
        synchronized (available) {
            if (available.size() < size) {
                available.put(obj, Boolean.valueOf(true));
                available.notify();
            }
        }
    }

Suis-je raté quelque chose?

MODIFIER: L'exception se produit dans available.wait(); ligne.

pouvez-vous nous dire quelle est la ligne 474 dans le code source?
l'exception se produit dans disponible.wait(); ligne, mais la ligne 474 est de java.lang.La classe d'objet.

InformationsquelleAutor Andrey Adamovich | 2009-10-12

68

Voir la javadoc de l'Objet.attendre.

en particulier "Le thread courant doit être propriétaire de cet objet à l'écran." et "[jette] IllegalMonitorStateException - si le thread actuel n'est pas le propriétaire de l'objet du moniteur". Qui est, vous avez besoin de synchroniser sur l'objet que vous allez à l'appel en attente sur.

de sorte que votre code devrait être:
```
synchronized (available) {
    available.wait();
}
```
- Ce qu'il faut savoir: Utiliser le même modèle si cette exception se produit sur available.notify().
- J'ai essayé d'utiliser un synchronisée fonction au lieu d'un bloc pour faire la même chose, mais il a jeté l'IllegalMonitorStateException. Pourquoi est-ce?
- Hunter, lorsque vous effectuez une fonction membre synchronisé vous prenez un verrou sur l'objet, donc this.wait() devrait fonctionner. Ce exactement avez-vous le faire?
- une méthode synchronisée est en effet le même que this.wait(), mais ceux propre le moniteur de l'objet dans lequel ces méthodes sont en cours d'exécution, pas available. Ce n'est donc pas le même que synchronized(available)
InformationsquelleAutor tgdavies
7

available.wait(); doivent être synchronisés(disponible) section

InformationsquelleAutor Maurice Perry
0

takeObject() la méthode doit être synchronisé ou de, nous devons l'écrire synchronisé bloc à l'intérieur de cette méthode. J'espère que u doit obtenir le temps de compilation d'exception pour cette.

InformationsquelleAutor prasad

Vous obtenez le "IllegalMonitorStateException" de

available.wait()

parce que le thread qui appelle le wait() la méthode n'est pas le propriétaire de l'Objet du moniteur qui est
référencé par le "disponible" la référence d'objet.

Pour un thread pour devenir le propriétaire d'un objet à l'écran, il y a 3 façons.

Par l'exécution d'un synchronisé méthode d'instance de cet objet.
En exécutant le corps d'un bloc synchronisé qui se synchronise sur l'objet.
Pour les objets de type Classe par l'exécution d'un synchronisé méthode statique de la classe.

Simple exemple de code pour chaque scénario. Tous les trois extraits de code sont des classes séparées pour chaque type, il suffit de copier le code et l'exécuter. J'ai ajouté des commentaires lourdement dans le code pour expliquer ce qui se passe dans chaque cas. Si c'est trop de commentaires pour vous. il suffit de supprimer pour rendre le code plus concis.

Aussi, lire le code de la méthode main() de la première à se faire une idée sur threadOne et threadTwo premier.

Par l'exécution d'un synchronisé méthode d'instance de cet objet.

import static java.lang.System.out;

public class SynchronizedInstanceMethodClass {

    synchronized void synchronizedInstanceMethod() { //threadOne acquire the monitor for "this" and continue.

            try {

                out.println("EVENT #1 threadOne is about to strat waiting on the "
                        +"monitor it already has - [\"this\"]....");

                this.wait(); //The threadOne already have the monitor for "this", 
                            // just release the monitor and go and wait threadOne.

                out.println("EVENT #3 Notify received and continue execution...");

            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
    }


    synchronized void notifierForAllThreads() { //threadTwo acquire the monitor for "this", 
                                               //which was released by threadOne when it went to waiting and contine.

            out.println("EVENT #2 threadTwo is about to notify all threads(including threadOne) "
                    +"   waiting on the monitor of -[\"this\"]....");

            this.notifyAll(); //threadTwo who owns the monitor on "this" notifies all 
                             //threads waiting on "this" and releases the monitor
    }

    public static void main(String [] args) {

        SynchronizedInstanceMethodClass mc  = new SynchronizedInstanceMethodClass();
        Thread threadOne = new Thread(() -> {mc.synchronizedInstanceMethod();});
        Thread threadTwo = new Thread(() -> {mc.notifierForAllThreads();});

        threadOne.start(); //Start the waiting of Thread one
        threadTwo.start(); //Notify the waiting threadOne
    }

}

En exécutant le corps d'un bloc synchronisé qui se synchronise sur l'objet.

import static java.lang.System.out;

public class SynchronizedBlockClass {

    void synchronizedBlockInstanceMethod() {

        synchronized (this) { //threadOne acquire the monitor for "this" and continue.

            try {

                out.println("EVENT #1 threadOne is about to strat waiting on the "
                            +"monitor it already has - [\"this\"]....");

                this.wait(); //The threadOne already have the monitor for "this", 
                            // just release the monitor and go and wait threadOne.

                out.println("EVENT #3 Notify received and continue execution...");
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
        }
    }


    void synchronizedBlockNotifierForAllThreads() {

        synchronized (this) { //threadTwo acquire the monitor for "this", 
                             //which was released by threadOne when it went to waiting and continue.

                out.println("EVENT #2 threadTwo is about to notify all threads(including threadOne) "
                        +"   waiting on the monitor of -[\"this\"]....");

                this.notifyAll(); //threadTwo who owns the monitor on "this" notifies all 
                                 //threads waiting on "this" and releases the monitor
            }
    }

    public static void main(String [] args) {
        SynchronizedBlockClass mc  = new SynchronizedBlockClass();
        Thread threadOne = new Thread(() -> {mc.synchronizedBlockInstanceMethod();});
        Thread threadTwo = new Thread(() -> {mc.synchronizedBlockNotifierForAllThreads();});

        threadOne.start(); //Start the waiting of Thread one
        threadTwo.start(); //Notify the waiting threadOne
    }

}

Pour les objets de type Classe par l'exécution d'un synchronisé méthode statique de la classe.

import static java.lang.System.out;

public class StaticClassReferenceClass {

    void synchronizedBlockInstanceMethod() {

        synchronized (StaticClassReferenceClass.class) { //threadOne acquire the monitor for class literal and continue.

            try {

                out.println("EVENT #1 threadOne is about to strat waiting on the "
                            +"monitor it already has - [StaticClassReferenceClass.class]....");

                StaticClassReferenceClass.class.wait(); //The threadOne already have the monitor for the class literal, 
                            // So it just release the monitor and go and wait.

                out.println("EVENT #3 Notify received and continue execution...");
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
        }
    }


    void synchronizedBlockNotifierForAllThreads() {

        synchronized (StaticClassReferenceClass.class) { //threadTwo acquire the monitor for the class literal, 
                             //which was released by threadOne when it went to waiting.

                out.println("EVENT #2 threadTwo is about to notify all threads(including threadOne) "
                        +"   waiting on the monitor of -[StaticClassReferenceClass.class]....");

                StaticClassReferenceClass.class.notifyAll(); //threadTwo who owns the monitor on the class literal notifies all 
                                 //threads waiting on it and releases the monitor
            }
    }

    public static void main(String [] args) {
        StaticClassReferenceClass mc  = new StaticClassReferenceClass();
        Thread threadOne = new Thread(() -> {mc.synchronizedBlockInstanceMethod();});
        Thread threadTwo = new Thread(() -> {mc.synchronizedBlockNotifierForAllThreads();});

        threadOne.start(); //Start the waiting of Thread one
        threadTwo.start(); //Notify the waiting threadOne
    }

}

InformationsquelleAutor Jeewantha Samaraweera

Vous devez vous connecter pour publier un commentaire.