并发（四）

这篇写一个关于BlockingQueue的小例子。

BlockingQueue是阻塞队列，那么什么时候发生阻塞呢？一是队列，入列时没有值进行入列，二是出列时，没有值出列，这样就会发生阻塞。

代码例子如下：

class Toast {

    public enum Status {
        DRY, BUTTERD, JAMMED
    }
    
    private Status status = Status.DRY;
    private final int id;
    public Toast(int idn) {
        id = idn;
    }
    public void butter() {
        status = Status.BUTTERD;
    }
    public void jam() {
        status = Status.JAMMED;
    }
    public Status getStatus() {
        return status;
    }
    public int getId() {
        return id;
    }
    public String toString(){
        return "Toast " + id + ": " + status;
    }
}

import java.util.concurrent.LinkedBlockingDeque;

class ToastQueue extends LinkedBlockingDeque<Toast>{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    

}

import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Toaster implements Runnable {

    private ToastQueue taostQueut;
    private int count = 0;
    private Random rand = new Random(47);
    public Toaster(ToastQueue tq){
        taostQueut = tq;
    }
    @Override
    public void run() {

        try {
            while(!Thread.interrupted()){
                TimeUnit.MICROSECONDS.sleep(100 + rand.nextInt(500));
                Toast toast = new Toast(count++);
                System.out.println(toast);
                taostQueut.put(toast);
            }
        }catch (InterruptedException e) {
            System.out.println("Toaster interrupted");
        }
        System.out.println("Toaster off");
    }
}

public 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 toast = butteredQueue.take();
                toast.jam();
                System.out.println(toast);
                finishedQueue.put(toast);
            }
        }catch (InterruptedException e) {
            System.out.println("Butterer interrupted");
        }
        System.out.println("Butterer off");
    }
}

public class Eatter implements Runnable {

    private ToastQueue finishedQueue;
    private int counter = 0;
    public Eatter(ToastQueue tq){
        finishedQueue = tq;
    }
    @Override
    public void run() {

        try {
            while(!Thread.interrupted()){
                Toast toast = finishedQueue.take();
                if (toast.getId() != counter++ || toast.getStatus() != Toast.Status.JAMMED) {
                    System.out.println(">>>> Eooro: " + toast);
                    System.exit(1);
                } else {
                    System.out.println("chomp " + toast);
                }
            }
        }catch (InterruptedException e) {
            System.out.println("Eater interrupted");
        }
        System.out.println("Eater off");
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ToastOMatic {

    public static void main(String[] args) throws InterruptedException {

        ToastQueue dryQueue = new ToastQueue();
        ToastQueue butteredQueue = new ToastQueue();
        ToastQueue finishedQueue = new ToastQueue();
        ExecutorService servie = Executors.newCachedThreadPool();
        servie.execute(new Toaster(dryQueue));
        servie.execute(new Butter(dryQueue, butteredQueue));
        servie.execute(new Jammer(butteredQueue, finishedQueue));
        servie.execute(new Eatter(finishedQueue));
        TimeUnit.SECONDS.sleep(5);
        servie.shutdownNow();
    }

}

上面组成了一个关于蛋糕摸黄油的小例子，很简单。一条生产线的专门生产蛋糕，另一条生产线是，生产后的蛋糕上抹上黄油，最后摸完黄油的蛋糕，作为成品，可以被吃掉了！

代码中没有显式的使用锁，但是全都在队列的内部进行实现，十分的方便。

今天在使用了alibaba开发规范插件后，发现创建线程池的方法不佳，在此进行记录。以后注意。

ExecutorService servie = Executors.newCachedThreadPool();     原先是这样创建的。检查后报出如下提示信息

"线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。"

因此，改为如下形式：

        ExecutorService servie = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(),
                // user-defined ThreadFactory
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        thread.setName(r.getClass().getName());
                        return thread;
                    }
                },
                // user-defined Thread rejection policy
                new ThreadPoolExecutor.AbortPolicy());

自己以后创建线程池的时候会多多注意。