Java多线程设计模式详解学习笔记七——Producer-Consumer

public class Main {
	public static void main(String[] args) {
		Table table=new Table(3);
		new MakerThread("MakerThread-1", table, 12345).start();
		new MakerThread("MakerThread-2", table, 54345).start();
		new MakerThread("MakerThread-3", table, 62345).start();
		new EaterThread("EaterThread-1", table, 23455).start();
		new EaterThread("EaterThread-2", table, 43455).start();
		new EaterThread("EaterThread-3", table, 53455).start();
	}
}

public class EaterThread extends Thread{
	private final Table table;
	private final Random random;
	
	public EaterThread(String name,Table table,long seed) {
		super(name);
		this.table=table;
		random=new Random(seed);
	}
	
	@Override
	public void run() {
		try {
			while (true) {
				String cake=table.take();
				Thread.sleep(random.nextInt(1000));
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

public class MakerThread extends Thread{
	private final Table table;
	private final Random random;
	private static int id=0;
	
	public MakerThread(String name,Table table,long seed) {
		super(name);
		this.table=table;
		random=new Random(seed);
	}

	@Override
	public void run() {
		try {
			while (true) {
				Thread.sleep(random.nextInt(1000));
				String cake="[ Cake No: "+nextId()+" by "+getName()+"]";
				table.put(cake);
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
	
	private static synchronized int nextId() {
		return ++id;
	}
}

public class Table {
	private final String[] buffer;
	private int count;
	private int tail;
	private int head;
	
	public Table(int count) {
		buffer=new String[count];
		count=0;
		tail=0;
		head=0;
	}
	
	public synchronized String take() throws InterruptedException {
		while (count<=0) {
			wait();
		}
		String cake=buffer[head];
		head=(head+1)%buffer.length;
		count--;
		notifyAll();
		System.out.println(Thread.currentThread().getName()+" takes "+cake);
		return cake;
	}
	
	public synchronized void put(String cake) throws InterruptedException {
		System.out.println(Thread.currentThread().getName()+" put "+cake);
		while (count>=buffer.length) {
			wait();
		}
		buffer[tail]=cake;
		tail=(tail+1)%buffer.length;
		count++;
		notifyAll();
	}
}

运行就过如下：

MakerThread-1 put [ Cake No: 1 by MakerThread-1]
EaterThread-2 takes [ Cake No: 1 by MakerThread-1]
MakerThread-1 put [ Cake No: 2 by MakerThread-1]
EaterThread-1 takes [ Cake No: 2 by MakerThread-1]
MakerThread-1 put [ Cake No: 3 by MakerThread-1]
EaterThread-3 takes [ Cake No: 3 by MakerThread-1]
MakerThread-3 put [ Cake No: 4 by MakerThread-3]
EaterThread-2 takes [ Cake No: 4 by MakerThread-3]
MakerThread-2 put [ Cake No: 5 by MakerThread-2]
EaterThread-2 takes [ Cake No: 5 by MakerThread-2]
MakerThread-3 put [ Cake No: 6 by MakerThread-3]
EaterThread-1 takes [ Cake No: 6 by MakerThread-3]
MakerThread-1 put [ Cake No: 7 by MakerThread-1]
EaterThread-3 takes [ Cake No: 7 by MakerThread-1]
MakerThread-1 put [ Cake No: 8 by MakerThread-1]
MakerThread-1 put [ Cake No: 9 by MakerThread-1]
EaterThread-2 takes [ Cake No: 8 by MakerThread-1]
EaterThread-1 takes [ Cake No: 9 by MakerThread-1]
MakerThread-2 put [ Cake No: 10 by MakerThread-2]
MakerThread-2 put [ Cake No: 11 by MakerThread-2]

Producer-Consumer Pattern 的所有参与者

程序的类图如下

Producer是“生产者”的意思，是指产生数据的线程，而Consumer是“消费者”的意思，意指使用数据的线程。

生产者必须将数据安全的交给消费者。虽然这是这样的问题，但当生产者和消费者在不同线程上运行时，两者的处理速度差将是最大的问题。当消费者要取数据时生产者还没建立数据，或者是生产者建立出数据时消费者的状态还没办法接受数据等等。
Producer-Consumer Pattern是在生产者与消费者之间加入一个“桥梁参与者”，以这个桥梁参与者缓冲线程之间的处理速度差。Channel参与者介于Producer参与者、Consumer参与者之间，担任传递Data参与者中继站，通道的角色。

保护安全性的Channel参与者
范例程序中，Table类的put和take方法都是用了Guarded Suspension Pattern，但MakerThread类与EaterThread类都不想依于Table类的详细实现，也就是说MakerThread不比理会其他线程，只要调用put方法就好，而EaterThread也是只要会调用take方法就可以。使用synchronized、wait、notifyAll这些考略到多线程操作的程序代码，全部隐藏在Channel参与者Table类里面。

中间者存在的隐含的意义
因为Channel参与者的存在，Producer参与者和Consumer参与者这条多线程，才能保持协力、合作。而在在Single Thread Execution Pattern中曾经说过“Synchronized是在保护什么”？当时我们说过，思索线程的共享互斥问题时，把观察切入点放在“保护着什么”上面，会比较容易找到问题的结症。
上面的思维若整理成口诀，可以得到两句话：
一。线程的合作要想“放在中间的东西”
二。线程的互斥要想“应该保护的东西”

InterruptedException异常
Java的标准类链接库中，后面接着throws InterrupedException的方法的代表选手，有下面这3位：
Java.lang.Object类的wait方法
Java.lang.Thread类的sleep方法
Java.lang.Thread类的join方法
这个通常告诉我们下面两件事：
一、这是“需要花点时间”的方法
二、这是“可以取消”的方法
用一句话来说，后面接着throws InterruptedException的方法，是可能会花一点时间，但是可以取消的方法。
一、需要花点时间的方法
执行wait方法的线程，会进入等待区等待被notify/notifyAll，在等待期间，线程不会活动。故需要花费等待被notify/notifyAll的时间。
执行sleep方法的线程，会暂停执行参数内所设置的时间，这也是花费时间的方法。
执行join方法的线程，会等待到指定的线程结束为止。也就是会花费直到指定线程结束之前的这段时间
像上面三个方法，分别要等待“被notify/notifyAll、设置的时间、指定的线程结束”，的确都是“需要花点时间”的方法
二、可以取消的方法
因为需要画时间的操作，会降低程序的响应性，所以我们会希望像下面着阳光可以在中途放弃（取消）执行这个方法
   1、取消wait方法等待notify/notifyAll的操作
   2、取消sleep方法等待设置长度时间的限制
   3、取消join方法等待其他线程结束的操作