wait/notify应用举例实现生产者和消费者通讯模型

下面，在不考虑实用性等前提下，我们会实现一个最简单的生产者、消费者模型，仅仅只用来理解wait/notify的机制。

在这个例子里，将启动一个生产者线程、一个消费者线程。生产者检测到有产品可供消费时，通知消费者（notify）进行消费，同时自己进入等待状态（wait），如果检测到没有产品可供消费，则进行生产。
消费者检测到有产品可供消费时，则进行消费，消费结束没通知生产者进行生产，如果检测到没有产品可供消费，自然也通知生产者进行生产。
也就是说，生产者线程和消费者线程会互相等待和互相通知。他们会争夺同一个对象obj的锁，实现线程之间的通信

Product类：

public class Product {
    private static Integer count = 0;
 
    public static void add() {
        count++;
    }
 
    public static void delete() {
        count--;
    }
 
    public static Integer getCount(){
        return count;
    }
}

Produce类：

public class Produce implements Runnable {
 
    private Object object;
 
    public Produce(Object object) {
        this.object = object;
    }
 
    @Override
    public void run() {
        synchronized (object) {
            System.out.println("++++ 进入生产者线程");
            System.out.println("++++ 产品数量:" + Product.getCount());
            while (true) {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
 
                if (Product.getCount() <= 0) {
                    System.out.println("++++ 开始生产!");
                    Product.add();
                    System.out.println("++++ 生产后产品数量:" + Product.getCount());
                }else {
                    try {
                        // 通知消费者进行消费，自己进入等待
                        object.notify();
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
 
            }
 
        }
    }
}

Consume类：

import java.util.concurrent.TimeUnit;
 
public class Consume implements Runnable {
 
    private Object object;
 
    public Consume(Object object) {
        this.object = object;
    }
 
    @Override
    public void run() {
        synchronized (object) {
            System.out.println("---- 进入消费者线程");
            System.out.println("---- 当前产品数量:" + Product.getCount());
            // 判断条件是否满足（有没有产品可以消费），若不满足则等待
            while (true) {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (Product.getCount() <= 0) {
                    try {
                        System.out.println("---- 没有产品，进入等待");
                        // 通知生产者生产，自己进入等待
                        object.notify();
                        object.wait();
                        System.out.println("---- 结束等待,开始消费");
                        Product.delete();
                        System.out.println("---- 消费后产品数量:" + Product.getCount());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println("---- 已有产品，直接消费");
                    Product.delete();
                    System.out.println("---- 消费后产品数量:" + Product.getCount());
                }
 
 
            }
 
        }
    }
}

测试主类

public class ThreadTest {
 
    static final Object obj = new Object();
 
 
    public static void main(String[] args) throws Exception {
 
        Thread consume = new Thread(new Consume(obj), "Consume");
        Thread produce = new Thread(new Produce(obj), "Produce");
        // 先启动消费者
        consume.start();
        produce.start();
 
 
    }
 
 
}

程序会一直运行下去。