Java multi-threading 'Waiting/Notification Mechanism'

Classic paradigm:

The waiting party follows the following principles:

1. Obtain the lock of the object.
2. If the conditions are not met, call the wait() method of the object and still check the conditions after being notified.
3. If the conditions are met, the corresponding logical task will be executed.
The pseudo code is as follows:

synchronized(对象) { 
        while(条件不满足) { 
            对象.wait(); 
        } 
        完成任务逻辑 
     }

The notifying party follows the following principles:
1. Obtain the object's lock.
2. Change the conditions.
3. Notify all threads waiting on the object.
The pseudo code is as follows:

• synchronized(对象) { 
  
          改变对象 
  
          对象.notifyAll(); 
  
      }

Sample code:

import java.text.SimpleDateFormat;import java.util.Date;/**
 * 线程等待/通知机制
 * Created by peng on 2018/7/22.
 */public class WaitNotify {

    private static boolean flag = true;    private static Object lock = new Object();    public static void main(String[] args) {
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        SleepUtils.second(1);

        Thread notifyThread = new Thread(new Notify(), "NotifyThread");
        notifyThread.start();
    }    private static class Wait implements Runnable {
        @Override
        public void run() {            // 加锁，拥有lock的Monitor
            synchronized (lock) {                // 当条件不满足时，继续wait，同时释放了lock的锁
                while (flag) {                    
                try {
                        System.out.println(Thread.currentThread() + " flag is true. wait @ "
                                + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }                // 条件满足时，完成工作
                System.out.println(Thread.currentThread() + " flag is false. running @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }    
    private static class Notify implements Runnable {
        @Override
        public void run() {            // 加锁，拥有lock的Monitor
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock. notify @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                SleepUtils.second(5);
            }            // 再次加锁
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                SleepUtils.second(5);
            }
        }
    }
}

The above is the detailed content of Java multi-threading 'Waiting/Notification Mechanism'. For more information, please follow other related articles on the PHP Chinese website!