Java多线程 - 线程通信（线程协作）

生产者消费者模式

举个例子，我作为消费者去肯德基买鸡块吃，正常情况下，如果还有鸡块的话就直接卖给我了，如果没有的话，前台就会通知后面的大厨进行制作，那么大厨就相当于是生产者。大厨做好之后会给到前台，然后前台通知我（消费者）来取餐。

在线程中，生产者是一条线程，消费者是一条线程，中间有个产品，如果有产品的话就进行通知，没有的话就进行等待。这样一来，两条线程之间就有了依赖及协作。

应用场景：

• 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
• 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
• 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待直到仓库中再次放入产品为止
  
  分析：这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
• 对于生产者，没有生产产品之前，要通知消费者等待.而生产了产品之后，又需要马上通知消费者消费
• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
• 在生产者消费者问题中，仅有 synchronized是不够的
  • synchronized可阻止并发更新同一个共享资源，实现了同步
  • synchronized不能用来实现不同线程之间的消息传递(通信)

Java提供了几个方法解决线程之间的通信问题

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的亳秒数
notify	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wa(方法的线程，优先级别高的线程优先调度

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

解决方式1 - 管程法

并发协作模型 “生产者/消费者模式” —> 管程法

• 生产者:负责生产数据的模块（可能是方法，对象，线程，进程）
• 消费者:负责处理数据的模块（可能是方法，对象，线程，进程）
• 缓冲区:消费者不能直接使用生产者的数据,他们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

用代码模拟一个场景：

生产者只顾生产，消费者只顾消费，利用一个缓冲区，容量大小为10；
缓冲区有两个方法：

• 放入产品：当产品丢过来的时候，先判断一下缓冲区有没有满，如果满了，生产者就要进行等待；如果没满，就把产品放进去，有了产品之后，就通知消费者进行消费。
• 消费产品：消费之前先判断有没有产品，如果有就直接进行消费，消费完了通知生产者；如果没有，就进行等待，等待生产者的通知。

public class ThreadDemo {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Productor(synContainer).start();
        new Consumer(synContainer).start();
    }
}

// 生产者
class Productor extends Thread {
    SynContainer synContainer;

    public Productor(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

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


// 消费者
class Consumer extends Thread {
    SynContainer synContainer;

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

    // 消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第--->" + synContainer.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) {
        // 如果容器满了，就需要等待消费者消费
        if (count == chickens.length) {
            // 通知消费者消费，生产者进行等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果容器没满，就需要放入产品
        chickens[count] = chicken;
        count++;

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

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

        // 如果可以消费
        count--;

        // 消费完了，通知生产者生产
        this.notifyAll();

        // 返回消费的是哪只鸡
        return chickens[count];
    }
}

可以看到，生产者生产完了，消费者立马消费，消费者消费完了，生产者又立马生产；这是一个轮流的过程，一直保持着生产者跟消费者之间的互相等待。

解决方式2 - 信号灯法

并发协作模型“生产者/消费者模式” —> 信号灯法
使用一个标志位，如果标志位为true，就等待，如果为false，就通知另一个线程。

代码模拟场景：
演员（生产者）表演节目，观众（消费者）观看节目。
用一个标志位控制线程什么时候等待，什么时候通知。

public class ThreadDemo2 {
    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++) {
            this.tv.play("电视剧第" + i + "段");
        }
    }
}


// 消费者 -> 观众
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();
            }
        }
        this.voice = voice;
        System.out.println("演员表演了：" + voice);
        this.flag = !this.flag;
        // 通知观众观看
        this.notifyAll();
    }

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

演员演一段，观众看一段