举个例子，我作为消费者去肯德基买鸡块吃，正常情况下，如果还有鸡块的话就直接卖给我了，如果没有的话，前台就会通知后面的大厨进行制作，那么大厨就相当于是生产者。大厨做好之后会给到前台，然后前台通知我（消费者）来取餐。
在线程中，生产者是一条线程，消费者是一条线程，中间有个产品，如果有产品的话就进行通知，没有的话就进行等待。这样一来，两条线程之间就有了依赖及协作。
应用场景：
Java提供了几个方法解决线程之间的通信问题
| 方法名 | 作用 |
|---|---|
| wait() | 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁 |
| wait(long timeout) | 指定等待的亳秒数 |
| notify | 唤醒一个处于等待状态的线程 |
| notifyAll() | 唤醒同一个对象上所有调用wa(方法的线程，优先级别高的线程优先调度 |
注意：均是 Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常 llegalMonitorStateException
并发协作模型 “生产者/消费者模式” —> 管程法
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据
用代码模拟一个场景：
生产者只顾生产，消费者只顾消费，利用一个缓冲区，容量大小为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];
}
}
可以看到，生产者生产完了，消费者立马消费，消费者消费完了，生产者又立马生产；这是一个轮流的过程，一直保持着生产者跟消费者之间的互相等待。
并发协作模型“生产者/消费者模式” —> 信号灯法
使用一个标志位，如果标志位为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();
}
}
演员演一段，观众看一段