Как использовать wait и notify в Java без IllegalMonitorStateException?

при использовании wait и notify или notifyAll методы в Java необходимо помнить следующие вещи:

1. использовать notifyAll вместо notify Если вы ожидаете, что больше, чем один поток будет ждать замок.
2. The wait и notify методы должны вызываться в синхронизированном контексте. См. ссылку для более подробного объяснения.
3. всегда называю wait() метод в цикле, потому что если несколько потоки ждут блокировки, и один из них получил блокировку и сбросил условие, затем другим потокам нужно проверить условие после того, как они проснутся, чтобы увидеть, нужно ли им снова ждать или можно начать обработку.
4. используйте тот же объект для вызова wait() и notify() метод; каждый объект имеет свой собственный замок так называя wait() на объекте А и notify() на объекте B не будет никакого смысла.

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

возможно, стоило бы измерить это время, прежде чем делать относительно сложную работу с резьбой ?

Если вам нужно прорезать его, я бы создал " N "потоков для выполнения умножения ячеек (возможно," n " - это количество доступных вам ядер), а затем использовать ExecutorService и будущее механизм для отправки нескольких умножений одновременно.

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

допустим, у вас есть приложение "черный ящик" с некоторым классом с именем BlackBoxClass что есть способ doSomething();.

кроме того, у вас есть наблюдатель или слушатель с именем onResponse(String resp) это будет называться BlackBoxClass после неизвестного времени.

поток-это просто:

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

допустим, мы не знаем, что происходит с BlackBoxClass и когда мы должны получить ответ, но вы не хотите продолжать свой код пока не получите ответа или другими словами сделать onResponse звонок. Сюда входит 'Synchronize 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) {
        }
    }
}
}

теперь мы можем реализовать то, что мы хотим:

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 только на объектах, где у вас есть свой монитор. Так что вам нужно что-то вроде

synchronized(threadObject)
{
   threadObject.notify();
}

notify() также необходимо синхронизировать

Я буду прав простой пример покажет вам правильный способ использования wait и notify в Java. Поэтому я создам два класса с именем ThreadA & ThreadB. ThreadA будет называть ThreadB.

public class ThreadA {
    public static void main(String[] args){
        ThreadB b = new ThreadB();//<----Create Instance for seconde class
        b.start();//<--------------------Launch thread

        synchronized(b){
            try{
                System.out.println("Waiting for b to complete...");
                b.wait();//<-------------WAIT until the finish thread for class B finish
            }catch(InterruptedException e){
                e.printStackTrace();
            }

            System.out.println("Total is: " + b.total);
        }
    }
} 

и для класса ThreadB:

class ThreadB extends Thread{
    int total;
    @Override
    public void run(){
        synchronized(this){
            for(int i=0; i<100 ; i++){
                total += i;
            }
            notify();//<----------------Notify the class wich wait until my    finish 
//and tell that I'm finish
            }
        }
    }

мы можем вызвать notify для возобновления выполнения ожидающих объектов как

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!");
}

возобновите это, вызвав notify на другой объект того же класса

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

простое использование, если вы хотите, как выполнять потоки альтернативно : -

public class MyThread {
    public static void main(String[] args) {
        final Object lock = new Object();
        new Thread(() -> {
            try {
                synchronized (lock) {
                    for (int i = 0; i <= 5; i++) {
                        System.out.println(Thread.currentThread().getName() + ":" + "A");
                        lock.notify();
                        lock.wait();
                    }
                }
            } catch (Exception e) {}
        }, "T1").start();

        new Thread(() -> {
            try {
                synchronized (lock) {
                    for (int i = 0; i <= 5; i++) {
                        System.out.println(Thread.currentThread().getName() + ":" + "B");
                        lock.notify();
                        lock.wait();
                    }
                }
            } catch (Exception e) {}
        }, "T2").start();
    }
}

ответ :-

T1:A
T2:B
T1:A
T2:B
T1:A
T2:B
T1:A
T2:B
T1:A
T2:B
T1:A
T2:B

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

Это похоже на ситуацию производитель-потребитель шаблон. Если вы используете java 5 или выше, вы можете рассмотреть возможность использования очереди блокировки (java.утиль.параллельный.BlockingQueue) и оставьте работу по координации потоков в базовой реализации framework/api. См. пример из java 5: http://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/BlockingQueue.html или java 7 (то же самое образец): http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/BlockingQueue.html

вы правильно охраняли свой блок кода, когда вы звоните wait() метод с помощью synchronized(this).

но вы не приняли такие же меры предосторожности, когда вы звоните notify() метод без использования защищенного блока:synchronized(this) или synchronized(someObject)

если вы обратитесь к странице документации oracle на объект класс, в котором содержится wait(),notify(),notifyAll() методы, вы можете увидеть ниже меры предосторожности во всех этих трех методов

этот метод должен только вызывается потоком, который является владельцем монитора этого объекта

за последние 7 лет многое изменилось, и давайте посмотрим на другие альтернативы synchronized в ниже SE вопросы:

зачем использовать ReentrantLock, если можно использовать synchronized (this)?

синхронизация против блокировки

избегайте синхронизации (это) в Java?