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

线程通信

Java提供了几个方法解决线程之间的通信问题，这些方法均是Object中的方法。

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

为什么这些方法被定义子啊Object中？

Java的每个对象中都有一个锁(monitor，也可以成为监视器) 并且wait()，notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。在Java的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法是Object类的一部分，这样Java的每一个类都有用于线程间通信的基本方法

生产者消费者

管城法：

public class 生产者消费者 {
	public static void main(String[] args) {
		SynContainer synContainer = new SynContainer();
		
		new Productor(synContainer).start();
		new Consumer(synContainer).start();
	}
	
}

//生产者
class Productor extends Thread{
	SynContainer container;
	
	public Productor(SynContainer container) {
		this.container = container;
	}
	
	//生产
	public void run() {
		for(int i = 1 ; i <= 100 ; i++) {
			System.out.println("生产了"+i+"只鸡！");
			container.push(new Chicken(i));
		}
	}
}

//消费者
class Consumer extends Thread{
	SynContainer container;
	
	public Consumer(SynContainer container) {
		this.container = container;
	}
	
	//消费
	public void run() {
		for(int i = 1 ; 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) {
		//如果容器满了,需要等待消费
		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--;
		Chicken chicken = chickens[count];
		
		//通知生产者生产
		this.notifyAll();
		
		return chicken;
		
	}
}

信号灯法：

//信号灯法
public class 生产者消费者2 {
	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{
	//演员表演，观众等待 T
	//观众观看，演员等待 F
	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;
	}
	
}