线程通信-生产者消费者问题

生产者消费者问题：
1、假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库﹐消费者将仓库中产品取走消费．
2、如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待﹐直到仓库中的产品被消费者取走为止.
3、如果仓库中放有产品﹐则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止．

这是一个线程同步问题,生产者和消费者共享同一个资源（产品），并且生产者和消费者之间相互依赖，互为条件．
对于生产者﹐没有生产产品之前，要通知消费者寺待﹒而生广J广加口，人需要马上通知消费者消费
对于消费者﹐在消费之后，要通知生产者已结束消费，需要生产新的产品以供消费
线程之间要怎么进行通信呢？
在生产者消费者问题中,仅有synchronized是不够的：
1、synchronized可阻止并发更新同一个共享资源，实现了同步
2、synchronized不能用来实现不同线程之间的消息传递(通信)

java提供了几个方法，来解决线程之间通信的问题：

注意:均是Object类的方法,都只能在同步方法或者同步代码块中
使用,否则会抛出异常IlegalMonitorStateException

解决方法：管程法与信号灯法

解决方法一–管程法：
生产者:负责生产数据的模块(可能是方法、对象、线程、进程);
消费者:负责处理数据的模块(可能是方法、对象、线程、进程);
缓冲区:消费者不能直接使用生产者的数据，他们之间有个“缓冲区"
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

上代码：

package com.wu;

//测试：生产者消费者模型-->利用缓冲区解决：管程法

//生产者、消费者、产品、缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Producer(container).start();
        new Consumer(container).start();

    }
}

//生产者：
class Producer extends Thread{
    SynContainer container; //缓冲区

    public Producer(SynContainer container){
        this.container = container;
    }

    //生产者，进行生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" +i +"只鸡");
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container; //缓冲区

    public Consumer(SynContainer container){
        this.container = container;
    }

    //消费者，进行消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->"+ container.pop().id + "只鸡");
        }
    }
}

//产品:假设是鸡肉
class Chicken{
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized  void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        while(count == chickens.length){
            //通知消费者消费，生成等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，则需要丢入产品
        chickens[count] = chicken;
        count ++;

        //可以通知消费者消费了
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        while(count == 0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果可以消费，那就消费
        count --;
        Chicken chicken = chickens[count];
        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }
}

生产者生产，满了就等待并通知，消费者消费；
消费者消费完了，就通知生产者生产

....

生产了94只鸡
生产了95只鸡
生产了96只鸡
消费了-->93只鸡
消费了-->97只鸡
消费了-->96只鸡
消费了-->95只鸡
消费了-->94只鸡
生产了97只鸡
生产了98只鸡
消费了-->98只鸡
生产了99只鸡
消费了-->99只鸡

Process finished with exit code 0

解决方法二–信号灯法：
演员表演录制节目，观众观看，通过flag标志位来判断演员是否需要表演

package com.wu;

//生产者消费者模型--信号灯法
public class TestPC2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者 --> 演员
class Player extends Thread {
    Tv tv;

    public Player(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("快乐大本营");
            } else {
                this.tv.play("抖音：记录美好生活");
            }
        }
    }
}

//消费者 --> 观众
class Watcher extends Thread {
    Tv tv;

    public Watcher(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//生产者 --> 节目
class Tv {
    //演员表演录制，观众等待
    //观众观看，演员等待
    String voice; //表演的节目
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了： " + voice);
        //通知观众观看
        this.notifyAll(); //通知唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了： " + voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

执行结果：

演员表演了： 快乐大本营
观看了： 快乐大本营
演员表演了： 抖音：记录美好生活
观看了： 抖音：记录美好生活
演员表演了： 快乐大本营
观看了： 快乐大本营
演员表演了： 抖音：记录美好生活
观看了： 抖音：记录美好生活
...
演员表演了： 抖音：记录美好生活
观看了： 抖音：记录美好生活
演员表演了： 快乐大本营
观看了： 快乐大本营
演员表演了： 抖音：记录美好生活
观看了： 抖音：记录美好生活

Process finished with exit code 0

以上例子演示了怎么解决线程通信-生产者消费者问题，一个线程等待另一个线程唤醒