java编程思想笔记-并发之线程协作(四)

1.生产者，消费者队列

wait()和notifyAll()方法以每次交互握手的方式解决任务操作问题，concurrent类库使用BlockingQueue同步队列来解决任务的协作问题,同步队列在任何时刻只允许一个任务插入或者移除元素，这个接口有两个常用的实现LinkedBlockingQueue和ArrayBlockingQueue，前者是无界队列，后者具有固定的尺寸
如果消费者尝试获取空队列元素，那么这个队列可以挂起消费者，并在更多的元素可用时恢复消费者队列

示例
制作一个吐司需要烘干吐司，抹黄油，涂果酱三个步骤，利用BlockingQueue模拟吐司工厂生产吐司

class Toast{
    public enum Status{
        DRY,BUFFERED,JAMMED
    }
    private Status status=Status.DRY;
    private final int id;
    public Toast(int idn){
        this.id=idn;
    }
    public void butter(){
        status=Status.BUFFERED;
    }
    public void jam(){
        status=Status.JAMMED;
    }
    public Status getStatus(){
        return status;
    }
    public int getId(){
        return id;
    }
    @Override
    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){
        this.toastQueue=tq;
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                TimeUnit.MILLISECONDS.sleep(100+rand.nextInt(500));
                Toast t=new Toast(count++);
                System.out.println(t);
                toastQueue.put(t);
            }
        } catch (Exception e) {
            System.out.println("ToasterInterruptException ");
        }
        System.out.println("Toaster off");
    }
}

class Butter implements Runnable{
    private ToastQueue dryQueue,butteredQueue;
    public Butter(ToastQueue dry,ToastQueue buttered) {
        dryQueue=dry;
        butteredQueue=buttered;
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                Toast t=dryQueue.take();
                t.butter();
                System.out.println(t);
                butteredQueue.put(t);
            }
        } catch (Exception e) {
            System.out.println("Butterer interrupted ");
        }
        System.out.println("Butterer off");
    }
}

class Jammer implements Runnable{
    private ToastQueue butteredQueue,finishedQueue;
    public Jammer(ToastQueue butteredQueue,ToastQueue finishedQueue){
        this.butteredQueue=butteredQueue;
        this.finishedQueue=finishedQueue;
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                Toast t=butteredQueue.take();
                t.jam();
                System.out.println(t);
                finishedQueue.put(t);
            }
        } catch (Exception e) {
            System.out.println("Jammer Interrupted");
        }
        System.out.println("Jammer Off");
    }
}

class Eater implements Runnable{
    private ToastQueue finishedQueue;
    private int counter;
    public Eater(ToastQueue finished){
        this.finishedQueue=finished;
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                Toast t=finishedQueue.take();
                if (t.getId()!=counter++||t.getStatus()!=Toast.Status.JAMMED) {
                    System.err.println(">>>> Error:"+t);
                    System.exit(1);
                }else {
                    System.out.println("Chomp!"+t);
                }
            }
        } catch (Exception e) {
            System.out.println("Easter interrupted");
        }
        System.out.println("Easter Off");
    }
}

public class ToastOMatic {
    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 Butter(dryQueue, butteredQueue));
        exec.execute(new Jammer(butteredQueue, finishedQueue));
        exec.execute(new Eater(finishedQueue));
        TimeUnit.SECONDS.sleep(5);
        exec.shutdownNow();
    }
}

从示例2可以看到，利用BlockingQueue避免了显示的使用wait，notify等方法

2.任务间使用管道输入输出

有时候需要利用输入输出在线程间通信，它们在Java输入输出类库中的对应物是PipedReader和PipedWriter，PipedReader是可中断的，interrupt()可以打断阻塞，而System.in.read()是不可中断的

示例：
利用PipedReader和PipedWriter打印26个大小写字母

class Sender implements Runnable{
    private Random random=new Random(47);
    private PipedWriter out=new PipedWriter();
    public PipedWriter getPipedWriter(){
        return out;
    }
    @Override
    public void run() {
        try {
            while (true) {
                for (char c='A';c<='z';c++) {
                    out.write(c);
                    TimeUnit.MILLISECONDS.sleep(random.nextInt(500));
                }
            }
        } catch (IOException e) {
            System.out.println("Sender-IOException");
        } catch (InterruptedException e) {
            System.out.println("Sender-InterruptedException");
        }
    }
}

class Receiver implements Runnable{
    private PipedReader in;
    public Receiver(Sender sender) throws IOException{
        in=new PipedReader(sender.getPipedWriter());
    }
    @Override
    public void run() {
        try {
            while (true) {
                System.out.println("Read:"+(char)in.read()+",");
            }
        } catch (Exception e) {
            System.out.println("Receiver-IOException");
        }
    }
}

public class PipedIO {
    public static void main(String[] args) throws Exception {
        Sender sender=new Sender();
        Receiver receiver=new Receiver(sender);
        ExecutorService exec=Executors.newCachedThreadPool();
        exec.execute(sender);
        exec.execute(receiver);
        TimeUnit.SECONDS.sleep(20);
        exec.shutdownNow();
    }
}

示例
利用BlockingQueue重写大小写字母示例

class Sender2 implements Runnable{
    private Random random=new Random(47);
    BlockingQueue<Character>bq;
    public Sender2(BlockingQueue<Character>bq){
        this.bq=bq;
    }
    @Override
    public void run() {
        try {
            while (true) {
                for (char c='A';c<='z';c++) {
                    bq.add(c);
                    TimeUnit.MILLISECONDS.sleep(random.nextInt(500));
                }
            }
        } catch (InterruptedException e) {
            System.out.println("Sender2-InterruptedException");
        }
    }
}

class Receiver2 implements Runnable{
    BlockingQueue<Character>bq;
    public Receiver2(BlockingQueue<Character>bq){
        this.bq=bq;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                char c=bq.take();
                System.out.println("receive:"+c);
            }
        } catch (InterruptedException e) {
            System.out.println("Receiver2-InterruptedException");
        }
    }

}

public class PipedIOBlockingQueue {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec=Executors.newCachedThreadPool();
        BlockingQueue<Character>queue=new LinkedBlockingQueue<Character>();
        exec.execute(new Sender2(queue));
        exec.execute(new Receiver2(queue));
        TimeUnit.SECONDS.sleep(5);
        exec.shutdownNow();
    }
}