Java生产者消费者模式举例

出现原因：死锁：过多的同步容易造成死锁

思想：

1.生产者生产。消费者等待，生产完成后通知消费者
2.消费者消费，生产者等待，消费完成后通知生产者

package tk.javazhangwei.thread.pro;
/***
 * 一个场景共同的资源
 * 生产者消费者模式    信号灯法
 * wait（）；等待，释放锁   sleep 不释放锁
 * notify（）/notifyAll（）；唤醒
 * 有synchronized 一起使用
 * @author zw
 *
 */
public class Movie {
	private String pic;
	//信号灯
	//flag--true   生产者生产。消费者等待，生产完成后通知消费者
	//flag--false  消费者消费，生产者等待，消费完成后通知生产者
	private boolean flag = true;
	
	public synchronized void play(String pic) throws InterruptedException {
		if(!flag) {//生产者等待
			this.wait();
		}
		System.out.println("生产了："+pic);
		
		//开始生产
		Thread.sleep(500);
		//生产完毕
		this.pic = pic;
		//通知消费者
		this.notify();
		//生产者停下
		this.flag =false;
				
	}
	
	public synchronized void watch() throws InterruptedException {
		if(flag) {//消费者等待
			this.wait();
		}
		Thread.sleep(500);
		System.out.println("消费了"+pic);
		this.notifyAll();
		
		this.flag =true;
	}
}

package tk.javazhangwei.thread.pro;
/***
 * 生产者
 * @author zw
 *
 */
public class player implements Runnable {
	private Movie m;

	public player(Movie m) {
		super();
		this.m = m;
	}

	@Override
	public void run() {
		for(int i =0;i<20;i++) {
			if(i%2==0) {
				try {
					m.play("左青龙");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}else {
				try {
					m.play("右白虎");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
	
}

package tk.javazhangwei.thread.pro;

public class watcher implements Runnable {
	private Movie m;
	
	public watcher(Movie m) {
		super();
		this.m = m;
	}

	@Override
	public void run() {
		for(int i =0;i<20;i++) {
		try {
			m.watch();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
	}

}

package tk.javazhangwei.thread.pro;

public class App {
	public static void main(String[] args) {
		Movie m =new Movie();
		
		player p = new player(m);
		watcher w = new watcher(m);
		
		new Thread(p).start();
		new Thread(w).start();
	}
}

补充说一下sleep（）和wait（）区别

调用 sleep()方法，正在执行的线程主动让出 CPU 去执行其他线程，在 sleep()方法指定的时间过后， CPU 才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep()方法并不会释放锁， 即使当前线程使用 sleep()方法让出了 CPU，但其它被同步锁挡住了的线程也无法得到执行。


wait()  在一个已经进入了同步锁的线程内进行调用，让当前线程暂时让出同步锁，以便其它正在等待此 锁的线程可以得到同步锁并运行。当其它线程调用了 notify()方法后，调用 wait()方法的线程就会 解除 wait 状态，当再次获得同步锁后，程序可以继续向下执行。