线程池任务提交原理，阻塞任务队列与拒绝策略

ThreadPoolExecutor参数解析

之前学习线程池，发现线程池大致有四种创建方法：

newFixedThreadPool 创建一个指定大小的线程池
newCachedThreadPool 创建一个可缓冲的线程池
newSingleThreadExecutor 创建一个仅有一个线程的线程池。
newScheduledThreadPool 创建一个可周期性调度任务的线程池

	public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

观察他们的源码可以发现底层都是调用的 ThreadPoolExecutor。
阿里巴巴的 java 开发规范不建议使用这四种线程池创建方式，因为第二个参数最大线程数为 Integer.MAX_VALUE，或者任务队列无上界，造成大量的任务或大量的线程，从而造成 OOM。

比如 newFixedThreadPool 与 newSingleThreadExecutor 的阻塞队列容量都是 Integer.MAX_VALUE。而 newCachedThreadPool 与 newScheduledThreadPool 的最大线程数量都是 Integer.MAX_VALUE ，这些都会造成巨大的问题。
强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式。

下面主要解析ThreadPoolExecutor的创建方式
参数介绍：

corePoolSize 核心线程数：

核心线程会一直存活，即使没有任务需要处理。当线程数小于核心线程数时，即使现有的线程空闲，线程池也会优先创建新线程来处理任务，而不是直接交给现有的线程处理。
核心线程在allowCoreThreadTimeout被设置为true时会超时退出，默认情况下不会退出。
maximumPoolSize 最大线程数

当线程数大于或等于核心线程，且任务队列已满时，线程池会创建新的线程，直到线程数量达到maxPoolSize。如果线程数已等于maxPoolSize，且任务队列已满，则已超出线程池的处理能力，线程池会启用拒绝策略。
keepAliveTime 空闲线程的存活时间

当线程数量大于corePoolSize核心线程数，并有线程空闲时间达到keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。如果allowCoreThreadTimeout设置为true，则所有线程均会退出直到线程数量为0。
unit

keepAliveTime的时间单位
workQueue

任务队列,当没有空闲线程池的时候，将任务添加到任务队列中，等待线程空闲再去执行。
threadFactory

线程工厂,用于配置创建线程方式。如更改线程池中创建的线程名字等。
handler

线程池对拒绝任务的处理策略，当线程数量达到最大线程数量并且任务队列已满，就会执行拒绝策略。

注意：
线程池有一个属性private volatile boolean allowCoreThreadTimeOut;用于控制核心线程空闲时间会否会超时。
可用这个方法在线程池创建之后，使用之前来设置。默认为false.

pool.allowCoreThreadTimeOut(boolean value);
设置控制核心线程是否会超时和终止的策略，如果在keep-alive时间内没有任务到达，则在新任务到达时替换。当为false时，核心线程永远不会终止，因为缺少传入的任务。当为true时，同样适用于非核心线程的keep-alive策略也适用于核心线程。为了避免持续的线程替换，当设置为true时，keep-alive时间必须大于零。通常应该在池被积极使用之前调用此方法。

测试实例

通过具体的例子，来分析一下这些参数，以及查看一下线程池中任务提交流程。

查看线程池线程创建，任务队列，拒绝策略

import jdk.nashorn.internal.runtime.regexp.JoniRegExp;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 *
 * @author xiaogang.zhang
 */
public class ThreadPoolExecutorTest {
    public static class RunTask implements Runnable {

        private String taskName;

        public RunTask(String taskName) {
            this.taskName = taskName;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " [" + this.taskName + "] " + " running!");
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " [" + this.taskName + "] " + " is over!");
        }
    }

    public static void main(String[] args) {

        //创建线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(4, 6, 20,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(2), new ThreadFactory() {

            final private AtomicInteger atomicInteger = new AtomicInteger();

            @Override
            public Thread newThread(Runnable r) {
                //以原子方式将当前值加 1。
                int index = atomicInteger.incrementAndGet();
                System.out.println("create Thread: " + "Thread-" + index);
                return new Thread(r, "Thread-" + index);
            }
        }, new ThreadPoolExecutor.AbortPolicy());
		
		//设置核心线程永不过时
        pool.allowCoreThreadTimeOut(false);		

        for (int i = 1; i <= 20; i++) {
            pool.submit(new RunTask("task-" + i));
        }
	
		//关闭线程池
        pool.shutdown();
    }
}

上面的代码设定了线程池的参数：

核心线程数=4，
最大线程数=6，
空闲线程存活时间为20s,
任务队列为ArrayBlockingQueue容量为2，有界的阻塞数组
使用线程工厂来观测线程创建时机以及指定线程的名称。
拒绝策略为ThreadPoolExecutor.AbortPolicy()，处理程序会抛出一个RejectedExecutionException异常。
提价了20个任务

查看运行结果：

从运行结果中可以看出：

刚开始提交任务的时候，线程池中还没有线程，线程池开始创建线程，直到线程数量够用或者达到核心线程数量。然后核心线程开始执行提交的任务（task-1、task-2、task-3、task-4）。
核心线程刚开始创建了四个，对应执行提交的任务（task-1、task-2、task-3、task-4），后面提交的任务就开始加到任务队列中。可以看到编号5的位置开始执行任务(task-5、task-6)，这两个任务就是加入到任务队列中的，直到有空闲线程才开始执行。
当线程数量达到核心线程数，并且核心线程都没有空闲，任务队列也已经满了的时候，就开始创建新的线程来执行提交的任务。线程数量增加到了最大线程数量。
当新的任务提交时，此时线程数量达到了最大线程数量，并且没有线程空闲，任务队列也已经满了，就会启用拒绝策略，代码中的为ThreadPoolExecutor.AbortPolicy()，就会直接抛出RejectedExecutionException异常。

查看空闲线程的自动销毁
更改一下代码，让任务数为8，并且主线程睡眠30s，因为之前设定的空闲线程存活时间为20s。30s后查看线程池的线程数量。

		for (int i = 1; i <= 8; i++) {
            pool.submit(new RunTask("task-" + i));
        }
        TimeUnit.SECONDS.sleep(30);
        System.out.println(pool.getPoolSize());

查看运行结果：

发现线程数量又回到了核心线程数量。程序运行期间，由于任务队列已满，又新建了线程来处理任务，线程数量=最大线程数量。

当线程数量>核心线程数量的时候，如果线程处于空闲状态的时间超过keepAliveTime，时间单位为unit,该线程就会自动退出销毁。所以最后线程的数量就会收缩到核心线程数量。

线程池任务提交原理总结

当线程数小于核心线程数时，会创建线程来处理任务。
当线程数大于等于核心线程数时，如果任务队列没有满，将任务加进任务队列等待线程空闲时调用。
当线程数大于等于核心线程数，并且任务队列已满时，创建新的线程来执行任务（须保证线程数不大于最大线程数）。
当有线程调用结束，处于空闲状态，如果任务队列中有任务，则执行任务队列中的任务。
如果线程数大于核心线程数，并且线程空闲时间超过keepAliveTime，则该线程退出销毁。以保证线程数量收缩为核心线程数。

阻塞队列

ArrayBlockingQueue
由数组组成的有界阻塞队列。
容量一旦创建，后续无法修改。
元素是有顺序的，按照先入先出进行排序，从队尾插入数据数据，从队头拿数据；
队列满时，往队列中 put 数据会被阻塞，队列空时，往队列中拿数据也会被阻塞。

public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}

/**
 * Creates an {@code ArrayBlockingQueue} with the given (fixed)
 * capacity and the specified access policy.
 *
 * @param capacity the capacity of this queue
 * @param fair if {@code true} then queue accesses for threads blocked
 *        on insertion or removal, are processed in FIFO order;
 *        if {@code false} the access order is unspecified.
 * @throws IllegalArgumentException if {@code capacity < 1}
 */
public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}

第二个方法有两个参数，第一个参数为阻塞队列容量，第二个参数是否公平主要是读写锁是否公平。如果是公平锁，那么在锁竞争时，就会按照先来先到的顺序，如果是非公平锁，锁竞争时随机的。

初始容量<=0会抛出IllegalArgumentException异常。

LinkedBlockingQueue
有界链表阻塞队列。

底层数据结构就是一个链表，链表保存了头节点和尾节点。

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

/**
 * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity.
 *
 * @param capacity the capacity of this queue
 * @throws IllegalArgumentException if {@code capacity} is not greater
 *         than zero
 */
public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);
}

/**
 * Creates a {@code LinkedBlockingQueue} with a capacity of
 * {@link Integer#MAX_VALUE}, initially containing the elements of the
 * given collection,
 * added in traversal order of the collection's iterator.
 *
 * @param c the collection of elements to initially contain
 * @throws NullPointerException if the specified collection or any
 *         of its elements are null
 */
public LinkedBlockingQueue(Collection<? extends E> c) {
    this(Integer.MAX_VALUE);
    final ReentrantLock putLock = this.putLock;
    putLock.lock(); // Never contended, but necessary for visibility
    try {
        int n = 0;
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();
            if (n == capacity)
                throw new IllegalStateException("Queue full");
            enqueue(new Node<E>(e));
            ++n;
        }
        count.set(n);
    } finally {
        putLock.unlock();
    }
}

默认不传参时队列容量时 Integer.MAX_VALUE。
链表维护先入先出队列，新元素被放在队尾，获取元素从队头部拿；

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    // Note: convention in all put/take/etc is to preset local var
    // holding count negative to indicate failure unless set.
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        /*
         * Note that count is used in wait guard even though it is
         * not protected by lock. This works because count can
         * only decrease at this point (all other puts are shut
         * out by lock), and we (or some other waiting put) are
         * signalled if it ever changes from capacity. Similarly
         * for all other uses of count in other wait guards.
         */
        while (count.get() == capacity) {
            notFull.await();
        }
        enqueue(node);
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();
}

private void enqueue(Node<E> node) {
    // assert putLock.isHeldByCurrentThread();
    // assert last.next == null;
    last = last.next = node;
}

DelayQueue
延迟队列。本质上是个优先级队列，按照剩余时间的多少排序的队列。
SynchronousQueue

队列不存储数据，所以没有大小，也无法迭代；
插入操作的返回必须等待另一个线程完成对应数据的删除操作，反之亦然；
队列由两种数据结构组成，分别是后入先出的堆栈和先入先出的队列，堆栈是非公平的，队列是公平的。

拒绝策略

AbortPolicy
中止策略
该策略是默认饱和策略。
抛出一个RejectedExecutionException异常。

	public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }

DiscardPolicy
抛弃策略,直接丢弃不做任何操作。


        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }

修改测试用例代码

	ThreadPoolExecutor pool = new ThreadPoolExecutor(4, 6, 20,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(2), new ThreadFactory() {

            final private AtomicInteger atomicInteger = new AtomicInteger();

            @Override
            public Thread newThread(Runnable r) {
                //以原子方式将当前值加 1。
                int index = atomicInteger.incrementAndGet();
                System.out.println("create Thread: " + "Thread-" + index);
                return new Thread(r, "Thread-" + index);
            }
        },
//                new ThreadPoolExecutor.AbortPolicy()
                new ThreadPoolExecutor.DiscardPolicy()
        );
	
		for (int i = 1; i <= 10; i++) {
            pool.submit(new RunTask("task-" + i));
        }

运行发现后面提交的任务都被抛弃了。task-9、task-10并没有

DiscardOldestPolicy
抛弃旧任务策略，
将头任务出队。


        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }

修改测试用例

//创建线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(4, 6, 20,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(2), new ThreadFactory() {

            final private AtomicInteger atomicInteger = new AtomicInteger();

            @Override
            public Thread newThread(Runnable r) {
                //以原子方式将当前值加 1。
                int index = atomicInteger.incrementAndGet();
                System.out.println("create Thread: " + "Thread-" + index);
                return new Thread(r, "Thread-" + index);
            }
        },
//                new ThreadPoolExecutor.AbortPolicy()
//                new ThreadPoolExecutor.DiscardPolicy()
                new ThreadPoolExecutor.DiscardOldestPolicy()
        );

运行发现task-9和task-10都运行了，但是最早入队的task-5,task-6被抛弃了。

CallerRunsPolicy
调用者运行。
直接调用Runnable的run方法运行。

	public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }