IllegalMonitorStateException при ожидании () вызова

Я использую многопоточность в Java для моей программы. Я успешно запустил поток, но когда я использую Thread.wait(), он выбрасывает java.lang.IllegalMonitorStateException. Как я могу заставить поток ждать, пока он не будет уведомлен?

Вы должны быть в synchronizedблоке, Object.wait()чтобы работать.

Кроме того, я рекомендую смотреть на пакеты параллелизма вместо пакетов старой школы. Они безопаснее и с ними проще работать .

Удачного кодирования.

РЕДАКТИРОВАТЬ

Я предположил, что вы имели Object.wait()в виду в качестве исключения то, что происходит, когда вы пытаетесь получить доступ, не удерживая блокировку объектов.

waitопределяется в Object, а не это Thread. Монитор Threadнемного непредсказуем.

Хотя все объекты Java имеют мониторы, обычно лучше иметь выделенную блокировку:

private final Object lock = new Object();

Диагностику можно немного легче прочитать при небольших затратах памяти (около 2 КБ на процесс) с помощью именованного класса:

private static final class Lock { }
private final Object lock = new Lock();

Чтобы waitили notify/ notifyAllили объект, вам нужно удерживать блокировку с synchronizedоператором. Кроме того, вам понадобится whileцикл для проверки состояния пробуждения (найдите хороший текст о потоке, чтобы объяснить, почему).

synchronized (lock) {
    while (!isWakeupNeeded()) {
        lock.wait();
    }
}

Сообщать:

synchronized (lock) {
    makeWakeupNeeded();
    lock.notifyAll();
}

Стоит разобраться как в языке Java, так и в java.util.concurrent.locksблокировках (и java.util.concurrent.atomic) при работе с многопоточностью. Но используйте java.util.concurrentструктуры данных, когда вы можете.

Я знаю, что этой ветке уже почти 2 года, но все еще нужно закрыть ее, так как я также пришел на этот сеанс вопросов и ответов с той же проблемой ...

Пожалуйста, прочитайте это определение нелегальнойMonitorException снова и снова ...

IllegalMonitorException генерируется, чтобы указать, что поток попытался ждать на мониторе объекта или уведомить другие потоки, ожидающие на мониторе объекта, не имея указанного монитора.

Эта строка снова и снова говорит, что IllegalMonitorException возникает, когда возникает одна из двух ситуаций ....

1> ждать на мониторе объекта, не имея указанного монитора.

2> уведомить другие потоки, ожидающие на мониторе объекта, не имея указанного монитора.

Кто-то, возможно, получил ответы ... а кто нет, тогда, пожалуйста, проверьте 2 утверждения ...

синхронизированный (объект)

Object.wait ()

Если оба объекта одинаковы ... тогда не может появиться нелегальное исключение.

Теперь снова прочитайте определение IllegalMonitorException, и вы не забудете его снова ...

На основании ваших комментариев кажется, что вы делаете что-то вроде этого:

Thread thread = new Thread(new Runnable(){
    public void run() { // do stuff }});

thread.start();
...
thread.wait();

Есть три проблемы.

1. Как уже говорили другие, obj.wait()может быть вызван , только если текущий поток содержит примитив блокировки / мьютекс для obj. Если текущий поток не удерживает блокировку, вы получаете исключение, которое вы видите.

2. thread.wait()Вызов не делать то , что вы , кажется, ожидая , что это сделать. В частности, thread.wait() не заставляет назначенный поток ждать. Скорее это заставляет текущий поток ждать, пока некоторые другие потоки не вызовут thread.notify()или thread.notifyAll().

   На самом деле не существует безопасного способа заставить Threadэкземпляр сделать паузу, если он этого не хочет. (Ближайшее, что есть в Java, - это устаревший Thread.suspend()метод, но этот метод небезопасен, как объясняется в Javadoc.)

   Если вы хотите, чтобы вновь начавшаяся Threadпауза, лучший способ сделать это - создать CountdownLatchэкземпляр и сделать так, чтобы поток вызвал await()защелку, чтобы сделать паузу самостоятельно. Затем основной поток вызывает countDown()защелку, чтобы позволить приостановленной нити продолжить.

3. Ортогонально предыдущим точкам, использование Threadобъекта в качестве блокировки / мьютекса может вызвать проблемы. Например, Javadoc для Thread::joinговорит:

   Эта реализация использует цикл this.waitвызовов, обусловленных this.isAlive. Когда поток завершается this.notifyAll, вызывается метод. Рекомендуется , чтобы приложения не используют wait, notifyили notifyAllна Threadслучаях.

Поскольку вы не опубликовали код, мы вроде как работаем в темноте. Каковы детали исключения?

Вы вызываете Thread.wait () из потока или вне его?

Я спрашиваю об этом, потому что в соответствии с Javadoc для IllegalMonitorStateException, это:

Брошенный, чтобы указать, что поток попытался ждать на мониторе объекта или уведомить другие потоки, ожидающие на мониторе объекта, не имея указанного монитора.

Чтобы прояснить этот ответ, этот вызов ожидания в потоке также вызывает исключение IllegalMonitorStateException, несмотря на то, что он вызывается из синхронизированного блока:

     private static final class Lock { }
     private final Object lock = new Lock();

    @Test
    public void testRun() {
        ThreadWorker worker = new ThreadWorker();
        System.out.println ("Starting worker");
        worker.start();
        System.out.println ("Worker started - telling it to wait");
        try {
            synchronized (lock) {
                worker.wait();
            }
        } catch (InterruptedException e1) {
            String msg = "InterruptedException: [" + e1.getLocalizedMessage() + "]";
            System.out.println (msg);
            e1.printStackTrace();
            System.out.flush();
        }
        System.out.println ("Worker done waiting, we're now waiting for it by joining");
        try {
            worker.join();
        } catch (InterruptedException ex) { }

    }

Чтобы иметь дело с IllegalMonitorStateException, вы должны убедиться, что все вызовы методов wait, notify и notifyAll происходят только тогда, когда вызывающий поток владеет соответствующим монитором . Самое простое решение - заключить эти вызовы в синхронизированные блоки. Объект синхронизации, который должен вызываться в операторе синхронизации, - это тот, чей монитор должен быть получен.

Вот простой пример, чтобы понять концепцию монитора

public class SimpleMonitorState {

    public static void main(String args[]) throws InterruptedException {

        SimpleMonitorState t = new SimpleMonitorState();
        SimpleRunnable m = new SimpleRunnable(t);
        Thread t1 = new Thread(m);
        t1.start();
        t.call();

    }

    public void call() throws InterruptedException {
        synchronized (this) {
            wait();
            System.out.println("Single by Threads ");
        }
    }

}

class SimpleRunnable implements Runnable {

    SimpleMonitorState t;

    SimpleRunnable(SimpleMonitorState t) {
        this.t = t;
    }

    @Override
    public void run() {

        try {
            // Sleep
            Thread.sleep(10000);
            synchronized (this.t) {
                this.t.notify();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Вызов Thread.wait () имеет смысл внутри кода, который синхронизируется с объектом Thread.class. Я не думаю, что это то, что вы имели в виду.
Ты спрашиваешь

Как я могу заставить поток ждать, пока он не будет уведомлен?

Вы можете подождать только вашу текущую тему. Любую другую ветку можно только осторожно попросить подождать, если она согласится.
Если вы хотите дождаться какого-то условия, вам нужен объект блокировки - объект Thread.class - очень плохой выбор - это одноэлементный AFAIK, поэтому синхронизация с ним (за исключением статических методов Thread) опасна.
Подробности синхронизации и ожидания уже объясняются Томом Хоутином. java.lang.IllegalMonitorStateExceptionозначает, что вы пытаетесь дождаться объекта, с которым вы не синхронизированы - это незаконно.

Не уверен, поможет ли это кому-то еще или нет, но это было ключевым моментом, чтобы исправить мою проблему в ответе пользователя "Tom Hawtin - tacklin" выше:

synchronized (lock) {
    makeWakeupNeeded();
    lock.notifyAll();
}

Просто тот факт, что «lock» передается в качестве аргумента в synchronized (), и он также используется в «lock» .notifyAll ();

Как только я сделал это в тех 2 местах, я получил это работает

Я получил некоторое IllegalMonitorStateExceptionвремя, пытаясь разбудить поток в / из другого class/ потока. В java 8вы можете использовать lockфункции нового параллелизма API вместо из synchronizedфункций.

Я уже хранил объекты для asynchronousтранзакций websocket в WeakHashMap. Решение в моем случае состояло в том, чтобы также сохранить lockобъект вConcurrentHashMap для synchronousответов. Обратите внимание на condition.await(не .wait).

Для обработки многопоточности я использовал Executors.newCachedThreadPool()для создания пула потоков .

Те, кто использует версию Java 7.0 или ниже, могут ссылаться на код, который я использовал здесь, и он работает.

public class WaitTest {

    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void waitHere(long waitTime) {
        System.out.println("wait started...");
        lock.lock();
        try {
            condition.await(waitTime, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        lock.unlock();
        System.out.println("wait ends here...");
    }

    public static void main(String[] args) {
        //Your Code
        new WaitTest().waitHere(10);
        //Your Code
    }

}