Java 线程间通信案例（生产者和消费者）

（1）主函数

/**
 * 生产者消费者模式：
 * 生产者判断state是否为true，若为true则表示有包子，生产者休眠，等待消费者拿到true的状态进行消费；
 *                          若不为true说明现在没有包子，则生产包子，并将状态置为true，之后，将消费者唤醒。
 * 消费者判断状态是否为false，若为false则说明没有包子，消费者睡眠，等待生产者拿到false的状态开始生产；
 *                          若不为false则说明有包子，消费者进行消费，并将状态置位false，之后将生产者唤醒。
 */
public class BaoZiDemo {
    public static void main(String[] args) {
        BaoZI baoZI = new BaoZI();
        Product product = new Product(baoZI);
        Consumer consumer = new Consumer(baoZI);
        new Thread(product).start();//生产者线程
        new Thread(consumer).start();//消费者线程
    }
}

（2）包子对象

public class BaoZI {
    private String pi;
    private String xian;
    private boolean state=false;

    public BaoZI() {
    }

    public BaoZI(String pi, String xian, boolean state) {
        this.pi = pi;
        this.xian = xian;
        this.state = state;
    }

    public String getPi() {
        return pi;
    }

    public void setPi(String pi) {
        this.pi = pi;
    }

    public String getXian() {
        return xian;
    }

    public void setXian(String xian) {
        this.xian = xian;
    }
    public boolean getState() {
        return state;
    }

    public void setState(boolean state) {
        this.state = state;
    }
}

（3）生产者线程实现类

public class Product implements Runnable {
    private BaoZI bz;//锁对象，控制同步代码块

    public Product(BaoZI bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        while (true){
            synchronized (bz){
                if(bz.getState()){//为true表示现在有包子
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("生产一个包子");

                    bz.setState(true);
                    bz.notify();
                }

            }
        }
    }
}

（4）消费者线程实现类

public class Consumer implements Runnable {
    private BaoZI bz;//锁对象，控制同步代码块

    public Consumer(BaoZI bz) {
        this.bz = bz;
    }
    @Override
    public void run() {
        while(true){
            synchronized (bz){
                if(!bz.getState()){//状态为false,表示没有包子
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    System.out.println("消费者使用包子");
                    bz.setState(false);
                    bz.notify();
                }
            }
        }
    }
}