线程池的三种阻塞队列

三种阻塞队列：

   SynchronousQueue
   ArrayBlockingQueue
   LinkedBlockingQueue

---

SynchronousQueue

     无缓冲无界等待队列，超出核心线程个数的任务时，创建新的线程执行任务，直到线程数达到最大线程数，触发拒绝策略，可缓存任务数:0。测试代码如下：

---

public static void main(String[] args) {
		//2个核心线程最大线程为3的线程池
        Executor executors = new ThreadPoolExecutor(
                2, 3, 30, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(),
                new RejectHandler());
        execute(executors);
    }

    private static void execute(Executor executors) {
        executors.execute(new NameRunnable(1));
        executors.execute(new NameRunnable(2));
        executors.execute(new NameRunnable(3));
        executors.execute(new NameRunnable(4));
        executors.execute(new NameRunnable(5));
        executors.execute(new NameRunnable(6));
    }

    private static class NameRunnable implements Runnable {
        private int name;

        public NameRunnable(int name) {
            this.name = name;
        }

        public int getName() {
            return name;
        }

        @Override
        public void run() {
            System.out.println(name + " is running... ");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + " is end !!! ");
        }
    }

    /***
     * 拒绝的Runnable
     */
    private static class RejectHandler implements RejectedExecutionHandler {

        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            NameRunnable name = (NameRunnable) r;

            System.out.print(name.getName() + " is rejected ^^\n");
        }
    }

     执行结果：

     2个核心线程执行两个任务，第三个任务来时创建新的线程执行任务，此时线程数达到最大，后来的任务进来时，触发自定义拒绝策略。

---

ArrayBlockingQueue

     基于数组的先进先出的有界队列，超出核心线程个数的任务时，将任务加入在此数组，数组大小为创建时指定大小，当任务队列塞满时，创建新的线程执行任务，直到线程数达到最大线程数，触发拒绝策略，可缓存任务数:创建时指定队列大小。测试代码如下：

---

 //2个核心线程最大线程为3的线程池,阻塞队列大小为2
 Executor executors = new ThreadPoolExecutor(
                2, 3, 30, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2),
                new RejectHandler());
        execute(executors);

---

     执行结果：

     任务1，2由核心线程执行，3,4则放入任务队列，任务5由新创建线程执行，此时线程数达到最大，后来的任务进来时，触发自定义拒绝策略。

---

LinkedBlockingQueue

     基于链表的先进先出可选有界队列，超出核心线程个数的任务时，将任务加入在此队列，队列大小为创建时指定大小不指定时为Integer.MAX_VALUE，当任务队列塞满时，创建新的线程执行任务，直到线程数达到最大线程数，触发拒绝策略，可缓存任务数:默认为Integer.MAX_VALUE否则为创建时指定队列大小。测试代码如下：

---

//2个核心线程最大线程为3的线程池,阻塞队列大小为2
public static void main(String[] args) {
        Executor executors = new ThreadPoolExecutor(
                2, 6, 30, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(2),
                new RejectHandler());
        execute(executors);
    }

    private static void execute(Executor executors) {
        executors.execute(new NameRunnable(1));
        executors.execute(new NameRunnable(2));
        executors.execute(new NameRunnable(3));
        executors.execute(new NameRunnable(4));
        executors.execute(new NameRunnable(5));
        executors.execute(new NameRunnable(6));
        executors.execute(new NameRunnable(7));
        executors.execute(new NameRunnable(8));
        executors.execute(new NameRunnable(9));
        executors.execute(new NameRunnable(10));
        executors.execute(new NameRunnable(11));
        executors.execute(new NameRunnable(12));
        executors.execute(new NameRunnable(13));
        executors.execute(new NameRunnable(14));
    }

---

     执行结果：

     核心线程执行任务1,2，任务34被放入阻塞队列，任务5678由新创建的线程执行，此时线程数达到最大，后续任务触发拒绝策略。