Java wait notify解析

方法/ 作用

wait：线程自动释放占有的对象锁，并等待notify。
notify：随机唤醒一个正在wait当前对象的线程，并让被唤醒的线程拿到对象锁
notifyAll：唤醒所有正在wait当前对象的线程，但是被唤醒的线程会再次去竞争对象锁。因为一次只有一个线程能拿到锁，所有其他没有拿到锁的线程会被阻塞。推荐使用。

Java中规定，在调用这三个方法时，当前线程必须获得对象锁。因此就得配合synchronized关键字来使用。在synchronized拿到对象锁之后，synchronized代码块或者方法中，必定是会持有对象锁的，因此就可以使用wait()或者notify()。

常用范式：

syn(object) {
    //业务逻辑，改变条件
    object.notify()/notifyAll()
}

使用wait()、notify()来实现一个生产者、消费者模式：

public class ProductAndCusumer {
    private static LinkedList<String> queue = new LinkedList<>();   //需要将queue作为多线程操作的锁
    public static final int MAX_CAPACITY = 5;

    public static class Producter extends Thread {
        @Override
        public void run() {
            while(true) {
                synchronized (queue) {
                    if (queue.size() >= MAX_CAPACITY) {
                        Log.i(TAG, "队列已满");
                        try {
                            queue.wait();   //停止生产产品，此时在生产者的线程中，调用queue.wait主动去释放锁，让当前消费线程进入等待唤醒去拿锁
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    //可以生产数据
                    String product = "生产：" + Thread.currentThread().getName();
                    queue.add(product);
                    Log.i(TAG, product);

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    queue.notifyAll();  //唤醒所有线程拿锁
                }
            }
        }
    }

    public static class Consumer extends Thread {
        @Override
        public void run() {
            while(true) {
                synchronized (queue) {
                    if (queue.isEmpty()) {
                        Log.i(TAG, "队列为空");
                        try {
                            queue.wait();  //通知生产者生产数据
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    //可以消费数据
                    Log.i(TAG, "消费：" + queue.pop());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    queue.notifyAll();
                }
            }
        }
    }
}

调用：

        Producter().start()
        Consumer().start()

打印过程：

生产：Thread-5
生产：Thread-5
消费：生产：Thread-5
消费：生产：Thread-5
队列为空
生产：Thread-5
生产：Thread-5
生产：Thread-5
生产：Thread-5
生产：Thread-5
队列已满
消费：生产：Thread-5
消费：生产：Thread-5
消费：生产：Thread-5
消费：生产：Thread-5
消费：生产：Thread-5
队列为空
生产：Thread-5
生产：Thread-5
生产：Thread-5
生产：Thread-5
生产：Thread-5
队列已满
消费：生产：Thread-5
消费：生产：Thread-5
消费：生产：Thread-5
消费：生产：Thread-5
消费：生产：Thread-5
队列为空
生产：Thread-5
生产：Thread-5
生产：Thread-5
生产：Thread-5

锁池、等待池

锁池：某个对象的锁已被线程A拥有，其他线程要执行该对象的 synchronized 方法获取锁时就会进入该对象的锁池，锁池中的线程会去竞争该对象的锁
等待池：某个线程调用了某个对象的 wait 方法，该线程就会释放该对象的锁，进入该对象的等待池，等待池中的线程不会去竞争该对象的锁
调用 notify 会随机唤醒等待池中的一个线程，唤醒后会进入到锁池
调用 notifyAll 会唤醒等待池中的所有线程，唤醒后会都进入到锁池

如何让两个线程循环交替打印数字

使用Object的wait和notify实现

public class StrangePrinter {

    Object odd = new Object(); // 奇数条件锁
    Object even = new Object(); // 偶数条件锁
    private int max;

    private AtomicInteger status = new AtomicInteger(1); // AtomicInteger保证可见性，也可以用volatile

    public StrangePrinter(int max) {
        this.max = max;
    }

    public class MyPrinter implements Runnable {
        private String name;
        private int type; // 打印的类型，0：代表打印奇数，1：代表打印偶数

        public MyPrinter(String name, int type) {
            this.name = name;
            this.type = type;
        }

        @Override
        public void run() {
            if (type == 1) {
                while (status.get() <= max) { // 打印奇数
                    if (status.get() % 2 == 0) { // 如果当前为偶数，则等待
                        synchronized (odd) {
                            try {
                                odd.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    } else {
                        Log.i(TAG, name + " - " + status.getAndIncrement()); // 打印奇数
                        synchronized (even) { // 通知偶数打印线程
                            even.notify();
                        }
                    }
                }
            } else {
                while (status.get() <= max) { // 打印偶数
                    if (status.get() % 2 != 0) { // 如果当前为奇数，则等待
                        synchronized (even) {
                            try {
                                even.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    } else {
                        Log.i(TAG, name + " - " + status.getAndIncrement()); // 打印偶数
                        synchronized (odd) { // 通知奇数打印线程
                            odd.notify();
                        }
                    }
                }
            }
        }
    }
}

调用：

        val strangePrinter = StrangePrinter(20)
        val executorService = Executors.newFixedThreadPool(2)
        executorService.submit(strangePrinter.MyPrinter("Printer1", 0))
        executorService.submit(strangePrinter.MyPrinter("Printer2", 1))
        executorService.shutdown()

打印结果：

Printer2 - 1
Printer1 - 2
Printer2 - 3
Printer1 - 4
Printer2 - 5
Printer1 - 6
Printer2 - 7
Printer1 - 8
Printer2 - 9
Printer1 - 10
Printer2 - 11
Printer1 - 12
Printer2 - 13
Printer1 - 14
Printer2 - 15
Printer1 - 16
Printer2 - 17
Printer1 - 18
Printer2 - 19
Printer1 - 20

参考： //www.greatytc.com/p/2286499b4774

代码参考：

https://github.com/running-libo/JavaPrinciples