Java多线程中wait notify等待唤醒机制详解

import java.util.*;
public class Main {
    //创建一个将被两个线程同时访问的共享对象
    public static Object loker = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (loker){
                System.out.println("线程一初次获得对象锁，执行过程中调用锁对象的wait()方法~~");
                try {
                    loker.wait();
                    System.out.println("当线程一被唤醒后，后面的代码继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程一运行结束");
        },"线程一");
        Thread t2 = new Thread(()->{
            synchronized (loker){
                System.out.println("线程二初次获得对象锁，执行过程中调用锁对象的notify()方法~~");
                loker.notify();
                System.out.println("唤醒线程一前，后面的代码继续执行~~");
            }
            System.out.println("线程二结束");
        },"线程二");
        t1.start();
        //防止t2优先获得CPU执行权而错过唤醒t1
        Thread.sleep(1000);
        t2.start();
    }
}

import java.util.*;
public class Test {
    public static Object loker1 = new Object();
    public static Object loker2 = new Object();
    public static void main(String[] args) {
        System.out.println("打印顺序如下：");
        Thread t1 = new Thread(()->{
            //为了防止线程A的唤醒没有被线程B接受，这里先让线程A睡一会
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+": C");
            synchronized (loker1){
                loker1.notify();
            }
        },"线程C");
        Thread t2 = new Thread(()->{
            synchronized (loker1){
                //等待线程A的唤醒
                try {
                    loker1.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+": B");
            //线程B唤醒线程C
            synchronized (loker2){
                loker2.notify();
            }
        },"线程B");
        Thread t3 = new Thread(()->{
            //线程C等待线程A的唤醒
            synchronized (loker2){
                try {
                    loker2.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+": A");
        },"线程A");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

import java.util.*;
public class Demo {
    private static Object locker1 = new Object();
    private static Object locker2 = new Object();
    private static Object locker3 = new Object();
    public static void main(String[] args) throws InterruptedException {
        System.out.println("打印结果:");
        Thread t1 = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker1) {
                        locker1.wait();
                    }
                    System.out.print("A");
                    synchronized (locker2) {
                        locker2.notify();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker2) {
                        locker2.wait();
                    }
                    System.out.print("B");
                    synchronized (locker3) {
                        locker3.notify();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t3 = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker3) {
                        locker3.wait();
                    }
                    System.out.println("C");
                    synchronized (locker1) {
                        locker1.notify();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        t2.start();
        t3.start();
        //让三个线程都拿到锁
        Thread.sleep(1000);
        // 从线程 t1 启动
        synchronized (locker1) {
            locker1.notify();
        }
    }
}