java个人学习笔记19（多生产者多消费者+循环判断标记+notifyAll()+Lock+Condition）

1.多生产者多消费者

/**
多生产者多消费者问题
	pro1：连续生产，重复消费
	Rea：被唤醒的线程没有再判断flag标记，就直接生产或消费了。
	sol：被唤醒的线程必须再次判断flag标记，while（flag）代替if（flag）

	pro2:有可能产生死锁
	Rea:唤醒的不确定，有可能生产者线程唤醒了生产者线程
	sol：使用notifyAll()
*/

//共享资源
class Res
{
	private String name;
	private int num = 1;
	//定义flag标记，为true表示存在一个未被消费的资源，为false表示资源已被消费。
	private boolean flag;
	//生产资源
	public synchronized void setRes(String name){
		//判断标记，存在未被消费的资源则进程等待
		//使被唤醒的线程再次判断flag标记
		while(flag)
			try{this.wait();}catch(InterruptedException e){}
		this.name = name+"..."+num;
		num++;
		System.out.println(Thread.currentThread().getName()+"...Producer..."+this.name);
		//修改flag标记
		flag = true;
		//唤醒消费者
		this.notifyAll();
	}

	//消费资源
	public synchronized void getRes(){
		//判断标记，资源已被消费则进程等待
		//使被唤醒的线程再次判断flag标记
		while(!flag)
			try{this.wait();}catch(InterruptedException e){}
		System.out.println(Thread.currentThread().getName()+"...Customer..."+name);
		//修改标记
		flag = false;
		//唤醒生产者
		this.notifyAll();
	}
}

//生产者
class Pro implements Runnable
{
	private Res r;
	Pro(Res r){
		this.r = r;
	}
	public void run(){
		while(true)
			r.setRes("phone");
	}
}

//消费者
class Cus implements Runnable
{
	private Res r;
	Cus(Res r){
		this.r = r;
	}
	public void run(){
		while(true)
			r.getRes();
	}
}

class ProducerCustomerDemo1
{
	public static void main(String[] args) 
	{
		//创建一个资源
		Res r = new Res();
		//创建两个任务
		Pro p = new Pro(r);
		Cus c = new Cus(r);
		//创建两个生产者线程和两个消费者线程
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);
		Thread t4 = new Thread(c);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

pro1：

pro2：

效率有点低！

2.Lock和Condition接口实现高效多生产者多消费者

查阅API（jdk1.5以上）java.util.concurrent.lock 
lock接口：按照面向对象的思想，将锁单独封装成一个对象，
 并提供对锁的显示操作 lock()：获取锁  unlock()：释放锁
 是同步的替代


condition接口：是Object中的监视器方法的替代
await()  signal()  signalAll()
之前是将监视器方法封装到每一个对象中，现在是将监视器方法只封装到condition对象中


condition对象与lock对象的绑定
通过lock接口的newCondition()方法完成

/**
解决效率低下的问题：
一锁绑定两组监视器，一组监视生产者进程，另一组监视消费者进程

*/
import java.util.concurrent.locks.*;
//共享资源
class Res
{
	private String name;
	private int num = 1;
	//定义flag标记，为true表示存在一个未被消费的资源，为false表示资源已被消费。
	private boolean flag;
	//创建Lock对象，通过已经实现的类ReentrantLock
	private Lock l = new ReentrantLock();
	//创建监视器对象,并将监视器对象与锁对象绑定
	//生产者监视器
	private Condition c_Pro = l.newCondition();
	//消费者监视器
	private Condition c_Cus = l.newCondition();
	//生产资源
	public void setRes(String name){
		//获取锁
		l.lock();
		try{
			//判断标记，存在未被消费的资源则进程等待
			while(flag)
				try{c_Pro.await();}catch(InterruptedException e){}
			this.name = name+"..."+num;
			num++;
			System.out.println(Thread.currentThread().getName()+"...Producer..."+this.name);
			//修改flag标记
			flag = true;
			//唤醒消费者
			c_Cus.signal();
		}finally{
			//释放锁
			l.unlock();
		}
		
	}

	//消费资源
	public void getRes(){
		//获取锁
		l.lock();
		try{
			//判断标记，资源已被消费则进程等待
			while(!flag)
				try{c_Cus.await();}catch(InterruptedException e){}
			System.out.println(Thread.currentThread().getName()+"...Customer..."+name);
			//修改标记
			flag = false;
			//唤醒生产者
			c_Pro.signal();
		}finally{
			//释放锁
			l.unlock();
		}
	}
}

//生产者
class Pro implements Runnable
{
	private Res r;
	Pro(Res r){
		this.r = r;
	}
	public void run(){
		while(true)
			r.setRes("phone");
	}
}

//消费者
class Cus implements Runnable
{
	private Res r;
	Cus(Res r){
		this.r = r;
	}
	public void run(){
		while(true)
			r.getRes();
	}
}

class NewProducerCustomerDemo
{
	public static void main(String[] args) 
	{
		//创建一个资源
		Res r = new Res();
		//创建两个任务
		Pro p = new Pro(r);
		Cus c = new Cus(r);
		//创建两个生产者线程和两个消费者线程
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);
		Thread t4 = new Thread(c);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}