Thinking in Java学习笔记 吐司的制作和消费过程

多个LinkedBlockingQueue队列，每个流程都有一个或两个队列，从上一个流程的队列中获取吐司，本流程处理完毕之后放入下一流程的队列

每个流程通过LinkedBlockingQueue.take()方法取队列中的任务时，如果上一个流程没有完成任务，队列是空的，则会堵塞在take()方法这里

源码如下：

public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
                while (count.get() == 0) {
                    notEmpty.await();
                }
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

TostOMatic.java

package com.test.concurrent;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
/*
 * 
 * 土司生产者与消费者
 * 生产者包括toast、butter和jam三个流程
 */
class Toast{
	public enum Status{DRY,BUTTERED,JAMMED}
	private Status status=Status.DRY;
	private final int id;
	public Toast(int idn){
		id=idn;
	}
	public void butter(){
		status=Status.BUTTERED;
	}
	public void jam(){
		status=Status.JAMMED;
	}
	public Status getStatus(){
		return status;
	}
	public int getId(){
		return id;
	}
	public String toString(){
		return "Toast "+id+" :"+status;
	}
}
class ToastQueue extends LinkedBlockingQueue<Toast>{}

class Toaster implements Runnable{
	private ToastQueue toastQueue;
	private int count=0;
	private Random rand=new Random(47);
	public Toaster(ToastQueue tq){
		toastQueue=tq;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		try {
			while(!Thread.interrupted()){
				TimeUnit.MILLISECONDS.sleep(100+rand.nextInt(500));
				Toast t=new Toast(count++);
				System.out.print(t+"  ");
				toastQueue.put(t);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Toaster InterruptedException");
			e.printStackTrace();
		}
		
		System.out.println("-----------Toaset off----------------------");
	}
	
}

class Butterer implements Runnable{
	private ToastQueue dryQueue, butteredQueue;
	public Butterer(ToastQueue dry, ToastQueue buttered){
		dryQueue=dry;
		butteredQueue=buttered;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		try {
			while(!Thread.interrupted()){
				Toast t=dryQueue.take();
				t.butter();
				System.out.print(t+"  ");
				butteredQueue.put(t);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("butterer InterruptedException");
			e.printStackTrace();
		}
		
		System.out.println("----------butter off------------------------------");
	}
	
}
class Jammer implements Runnable{
	private ToastQueue butteredQueue,finishedQueue;
	public Jammer(ToastQueue buttered,ToastQueue finished){
		butteredQueue=buttered;
		finishedQueue=finished;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		try {
			while(!Thread.interrupted()){
				Toast t=butteredQueue.take();
				t.jam();
				System.out.print(t+"   ");
				finishedQueue.put(t);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Jammer InterruptedException");
			e.printStackTrace();
		}
		
		System.out.println("------------jam off---------------------");
	}
	
}
class Eater implements Runnable{
	private ToastQueue finishedQueue;
	private int counter=0;
	public Eater(ToastQueue finished){
		finishedQueue=finished;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while(!Thread.interrupted()){
				Toast t=finishedQueue.take();
				if(t.getId()!=counter++||t.getStatus()!=Toast.Status.JAMMED){
					System.out.println(">>>>>>Error:"+t);
				}else{
					System.out.println("   Chomp!! "+t);
				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Eater InterruptedException");
			e.printStackTrace();
		}
		System.out.println("-----------------Eater off-----------------");
	}
	
}
public class TostOMatic {
	public static void main(String [] args) throws InterruptedException{
		ToastQueue dryQueue=new ToastQueue(),
				   butteredQueue=new ToastQueue(),
				   finishedQueue=new ToastQueue();
		
		ExecutorService exec=Executors.newCachedThreadPool();
		exec.execute(new Toaster(dryQueue));
		exec.execute(new Butterer(dryQueue,butteredQueue));
		exec.execute(new Jammer(butteredQueue,finishedQueue));
		exec.execute(new Eater(finishedQueue));
		
		TimeUnit.SECONDS.sleep(5);
		exec.shutdownNow();
		
	}
}