线程基础（十）生产者/消费者模式 进阶 利用await()/signal()实现

利用await()/signal()实现生产者和消费者模型

一样，先定义一个缓冲区：

/*
 * 缓冲区
 */
public class Buffer {
	public static String buffer="";
}

package a_reentrantlock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test08 {
	private ReentrantLock lock = new ReentrantLock();
	
	private Condition condition = lock.newCondition();
	
	//如果缓冲区值为空则设置值，如果不为空则等待
	public void set(){
		try {
			lock.lock();
			while(!"".equals(Buffer.buffer)){
				condition.await();
			}
			Buffer.buffer="123";
			System.out.println("生产者生产数据为"+Buffer.buffer);
			condition.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void get(){
		try {
			lock.lock();
			while("".equals(Buffer.buffer)){
				condition.await();
			}
			System.out.println("消费者消费数据");
			Buffer.buffer="";
			condition.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final Test08 t =new Test08();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.set();
				}
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.get();
				}
			}
		});
		t1.start();
		t2.start();
	}
	
}

同样的，开两个线程，一个线程调用set()方法生产，另一个线程调用get()方法消费：

生产者生产数据为123
消费者消费数据
生产者生产数据为123
消费者消费数据
生产者生产数据为123
消费者消费数据
生产者生产数据为123
消费者消费数据
生产者生产数据为123
消费者消费数据
生产者生产数据为123
消费者消费数据

和wait()/notify()机制的实现效果一样，同样符合生产者/消费者模型

小心假死

生产者/消费者模型最终达到的目的是平衡生产者和消费者的处理能力，达到这个目的的过程中，并不要求只有一个生产者和一个消费者。可以多个生产者对应多个消费者，可以一个生产者对应一个消费者，可以多个生产者对应一个消费者。

假死就发生在上面三种场景下。理论分析就能说明问题，所以就不写代码了。代码要写也很简单，上面的两个例子随便修改一个，开一个生产者线程/多个消费者线程、开多个生产者线程/消费者线程、开多个生产者线程/多个消费者线程都可以。假死指的是全部线程都进入了WAITING状态，那么程序就不再执行任何业务功能了，整个项目呈现停滞状态。

比方说有生产者A和生产者B，缓冲区由于空了，消费者处于WAITING。生产者B处于WAITING，生产者A被消费者通知生产，生产者A生产出来的产品本应该通知消费者，结果通知了生产者B，生产者B被唤醒，发现缓冲区满了，于是继续WAITING。至此，两个生产者线程处于WAITING，消费者处于WAITING，系统假死。

同样上面的例子 新增生产者t3

public class Test08 {
	private ReentrantLock lock = new ReentrantLock();
	
	private Condition condition = lock.newCondition();
	
	//如果缓冲区值为空则设置值，如果不为空则等待
	public void set(){
		try {
			lock.lock();
			while(!"".equals(Buffer.buffer)){
				condition.await();
			}
			Buffer.buffer="123";
			System.out.println("生产者生产数据为"+Buffer.buffer);
			condition.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void get(){
		try {
			lock.lock();
			while("".equals(Buffer.buffer)){
				condition.await();
			}
			System.out.println("消费者消费数据");
			Buffer.buffer="";
			condition.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final Test08 t =new Test08();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.set();
				}
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.get();
				}
			}
		});
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.set();
				}
			}
		});
		t1.start();
		t2.start();
		t3.start();
	}
}

出现假死

上面的分析可以看出，假死出现的原因是因为notify的是同类，所以非单生产者/单消费者的场景，可以采取两种方法解决这个问题：

1、synchronized用notifyAll()唤醒所有线程、ReentrantLock用signalAll()唤醒所有线程

2、用ReentrantLock定义两个Condition，一个表示生产者的Condition，一个表示消费者的Condition，唤醒的时候调用相应的Condition的signal()方法就可以了

这里使用第二种方式

public class Test08 {
	private ReentrantLock lock = new ReentrantLock();
	
	private Condition condition = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	
	//如果缓冲区值为空则设置值，如果不为空则等待
	public void set(){
		try {
			lock.lock();
			while(!"".equals(Buffer.buffer)){
				condition.await();
			}
			Buffer.buffer="123";
			System.out.println("生产者生产数据为"+Buffer.buffer);
			condition2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void get(){
		try {
			lock.lock();
			while("".equals(Buffer.buffer)){
				condition2.await();
			}
			System.out.println("消费者消费数据");
			Buffer.buffer="";
			condition.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final Test08 t =new Test08();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.set();
				}
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.get();
				}
			}
		});
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					t.set();
				}
			}
		});
		t1.start();
		t2.start();
		t3.start();
	}
}

这里对比 和 wait/notify ，await()/signal() 可以利用多个Condition 进行消费/生产实现效果，不用通知所有线程，这里显得更加效率，方便

 

要实现生产消费模型，java提供了队列机制更加方便的实现