40

なぜこれが起こるのでしょうか？重要なのは、モニターオブジェクトが確実にnullではないということですが、それでもこの例外が頻繁に発生します。

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

これを引き起こすコードは、単純なプールソリューションです。

    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();
            }
        }
    }

私は何かが足りないのですか？

編集：例外はavailable.wait();行で発生します。

4

4 に答える 4

76

Object.waitのjavadocを参照してください。

特に「現在のスレッドはこのオブジェクトのモニターを所有している必要があります。」および「[throws]IllegalMonitorStateException-現在のスレッドがオブジェクトのモニターの所有者でない場合。」つまり、待機を呼び出すオブジェクトで同期する必要があります。

したがって、コードは次のようになります。

synchronized (available) {
    available.wait();
}
于 2009-10-12T11:03:13.713 に答える
7

available.wait();同期された（利用可能な）セクションにある必要があります

于 2009-10-12T10:58:07.327 に答える
1

から「IllegalMonitorStateException」を取得しています

available.wait()

wait（）メソッドを呼び出す現在のスレッドは、「使用可能な」オブジェクト参照によって参照されるオブジェクトのモニターの所有者ではないためです。

スレッドがオブジェクトのモニターの所有者になるには、3つの方法があります。

  1. そのオブジェクトの同期インスタンスメソッドを実行する。
  2. オブジェクト上で同期する同期ブロックの本体を実行する。
  3. クラスの同期静的メソッドを実行することにより、クラスタイプのオブジェクトの場合。

各シナリオの簡単なサンプルコード。3つのコードスニペットはすべて、タイプごとに個別のクラスであり、コードをコピーして実行するだけです。それぞれの場合に何が起こっているのかを説明するために、コードにコメントを大幅に追加しました。コメントが多すぎる場合。コードをより簡潔にするために、それらを削除するだけです。

また、最初にmain（）メソッドのコードを読んで、最初にthreadOneとthreadTwoについて理解してください。

  1. そのオブジェクトの同期インスタンスメソッドを実行する。

    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
    }

}

  2. オブジェクト上で同期する同期ブロックの本体を実行する。

    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
    }

}

  3. クラスの同期静的メソッドを実行することにより、クラスタイプのオブジェクトの場合。

    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
    }

}
于 2019-02-03T06:55:14.763 に答える
0

takeObject（）メソッドは同期する必要があります。または、このメソッド内に同期ブロックを書き込む必要があります。このためにコンパイル時の例外が発生することを願っています。

于 2013-10-15T12:46:47.987 に答える