---

普通方式 wait 与 notifyAll

消费者

package abc;

public class Customer extends Thread{
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                //判断顾客是否吃到上限数量了
                if (Desk.maxNum == 0) {
                    break;
                } else {
                    //桌子上有无食物
                    if (Desk.foodNum > 0) {
                        //修改桌子上食物数量
                        Desk.foodNum--;
                        //修改上限数量
                        Desk.maxNum--;
                        //有食物就吃
                        System.out.println("吃饭中，还能吃  " + Desk.maxNum + "个");
                        //吃完了告诉厨师继续
                        Desk.lock.notifyAll();
                    } else {
                        //没有食物就等待
                        try {
                            System.out.println("顾客等待");
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        }
    }
}

生产者

package abc;

public class Cook extends Thread {

    @Override
    public void run() {

        while (true) {
            synchronized (Desk.lock) {
                //判断是否到达食物上限
                if (Desk.maxNum == 0) {
                    break;
                } else {
                    //没有到达上限，继续做食物
                    //判断桌子上有无食物
                    if (Desk.foodNum != 0) {
                        //有食物，等待
                        try {
                            System.out.println("厨师等待");
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } else {
                        //没有食物，去做食物
                        System.out.println("厨师做食物");
                        Desk.foodNum++;
                        //提醒顾客去吃食物
                        Desk.lock.notifyAll();
                    }
                }

            }
        }


    }
}

桌子

package abc;

public class Desk{
    //食物数量
    public static int foodNum=0;
    //总个数
    public static int maxNum=40;
    //锁对象
    public static Object lock=new Object();
}

测试类

package abc;

public class Main {
    public static void main(String[] args) {

        Cook cook = new Cook();
        Customer customer = new Customer();

        cook.start();
        customer.start();
    }
}

运行结果

厨师做食物
厨师等待
吃饭中，还能吃  4个
顾客等待
厨师做食物
厨师等待
吃饭中，还能吃  3个
顾客等待
厨师做食物
厨师等待
吃饭中，还能吃  2个
顾客等待
厨师做食物
厨师等待
吃饭中，还能吃  1个
顾客等待
厨师做食物
厨师等待
吃饭中，还能吃  0个

---

阻塞队列

Cook生产者

package zu_se;
import java.util.concurrent.ArrayBlockingQueue;

public class Cook extends Thread 

    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            //开始做饭
            try {
                queue.put("食物");
                System.out.println("厨师做饭");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

Customer消费者

package zu_se;
import java.util.concurrent.ArrayBlockingQueue;

public class Customer extends Thread {

    ArrayBlockingQueue<String> queue;

    public Customer(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }


    @Override
    public void run() {
        while (true) {
            //开始做饭
            try {
                //从阻塞队列获取数据
                String food = queue.take();
                System.out.println("顾客吃" + "  " + food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

测试类

package zu_se;

import java.util.concurrent.ArrayBlockingQueue;

public class Main {
    public static void main(String[] args) {

        //创建阻塞队列
        //1.泛型是队列里面数据的属性， 2.必须要指定队列上限
        //传递队列给两个线程
        ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(3);
        //传递阻塞队列
        Cook cook=new Cook(queue);
        Customer customer=new Customer(queue);
        cook.start();
        customer.start()
    }
}