线程通信 管程法与信号灯法

应用场景:生产者和消费者问题
◆假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费.
◆如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待，直到仓库中的产品被消费者取走为止.
◆如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待，直到仓库中再次放入产品为止.

这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件.
◆对于生产者,没有生产产品之前,要通知消费者等待.而生产了产品之后，又
需要马.上通知消费者消费
◆对于消费者, 在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费.
◆在生产者消费者问题中，仅有synchronized是不够的
◆synchronized 可阻止并发更新同一个共享资源，实现了同步
◆synchronized 不能用来实现不同线程之间的消息传递(通信)

解决方式一 并发协作模型“生产者1消费者模式”–>管程法

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

//生产者消费者模型
public class TestPC {

	public static void main(String[] args) {
		SynContainer container = new SynContainer();
		new Productor(container).start();
		new Consumer(container).start();

	}

}
//消费者
class Consumer extends Thread{
	SynContainer container;//缓冲区
	public Consumer(SynContainer container) {
		this.container = container;
	}
	public void run() {
		for(int i =0;i<100;i++) {
			System.out.println("消费了" + container.pop().id + "只鸡");
		}
	}
	
}
//生产者
class Productor extends Thread{
	SynContainer container;//缓冲区
	public Productor(SynContainer container) {
		this.container = container;
	}
	public void run() {
		for(int i =0;i<100;i++) {
			container.push(new Chicken(i));
			System.out.println("生产有鸡"+ i +"只");
		}
	}
	
}
//产品
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) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//如果容器没有满 需要放入产品
		chickens[count] = chicken;
		count++;
		//通知该消费了
		this.notifyAll();
		
	}
	//消费者消费产品
	public synchronized Chicken pop() {
		if(count == 0) {
			//等待生产
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//消费
		count--;
		Chicken chicken = chickens[count];
		//吃完了通知生产
		this.notifyAll();
		//返回消费的鸡
		return chicken;
	}
}

解决方式2 ◆并发协作模型“生产者消费者模式”–>信号灯法

通过一个flag进行判断执行消费还是生产

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;
	}
	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;
	}
	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) {
				// TODO Auto-generated catch block
				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) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("观看了"+ voice);
		this.notifyAll();//通知演员表演
		this.flag = !this.flag;
	}
}