创建线程属性

• 我们可以通过ThreadPoolExecutor构造函数来创建一个线程池：

public class ThreadPoolExecutor extends AbstractExecutorService {

    /**
     * 用于记录线程池池的 状态和当前待work线程数量
     * 前3位记录线程池状态
     * 后29位记录运行work数量
     */
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

    /** Java 中Integer 类型长度为32位，线程池用一个int类型的前3位表示线程池的状态**/
    private static final int COUNT_BITS = Integer.SIZE - 3;

    /** 用来计算出当前线程池状态中间变量，同时也表示work最大数量
     *  00011111 11111111 11111111 11111111
     **/
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    /** -----------------线程池状态----------------- **/

    /**
     * 线程池RUNNING状态,当前状态下线程池可以接收新的任务，对新接收的任务进行处理，
     * 工厂正常运行
     *
     * -1 二进制 11111111111111111111111111111111 左移动 29位 前三位 111
     */
    private static final int RUNNING    = -1 << COUNT_BITS;

    /**
     * 线程池SHUTDOWN状态,当前状态下线程池不在接收新任务，对之前接收的任务(其中包括还在队列等待和正在执行的任务)
     *  工厂不在接收新的订单,工厂运行出现了问题
     *
     *  0 二进制 00000000000000000000000000000000 左移动 29位 前三位 000
     */
    private static final int SHUTDOWN   =  0 << COUNT_BITS;

    /**
     * 线程池STOP状态,当前状态下线程池不在接收新任务，对之前接收的任务存在队列没有处理的不在处理，正在执行做中断
     *  工厂不在接收新的订单,工厂要倒闭了
     *
     *  1 二进制 00000000000000000000000000000001 左移动 29位 前三位 001
     */
    private static final int STOP       =  1 << COUNT_BITS;

    /**
     * 线程池TIDYING状态,当前没有待执行的任务，等待执行注册到JVM的钩子函数terminated()
     *  工厂走倒闭程序，需要做最后清理工作
     *
     *  2 二进制 00000000000000000000000000000010 左移动 29位 前三位 010
     */
    private static final int TIDYING    =  2 << COUNT_BITS;

    /**
     * 执行完VM的钩子函数terminated()
     *  工厂关闭
     *  3 二进制 00000000000000000000000000000011 左移动 29位 前三位 011
     */
    private static final int TERMINATED =  3 << COUNT_BITS;

    /** 计算获取当前线程池状态 **/
    private static int runStateOf(int c)     { return c & ~CAPACITY; }

    /** 计算获取当前运行work数量**/
    private static int workerCountOf(int c)  { return c & CAPACITY; }


    /**
     * 即根据线程池的状态和worker数量合并成整形 ctl
     */
    private static int ctlOf(int rs, int wc) { return rs | wc; }


    /** 判断当前线程池是否小于s,c表示当前线程池状态 **/
    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    }

    /** 判断当前线程池是否大于等于s,c表示当前线程池状态 **/
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }

    /** 判断当前线程池是否正在正常运行  RUNNING状态**/
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }

    /**
     * 使用CAS增加线程池中work数量（后29位可以直接整数运算）
     * 成功返回true,失败返回false
     */
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }

    /**
     * 使用CAS减少线程池中work数量（后29位可以直接整数运算）
     * 成功返回true,失败返回false
     */
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }

    /**
     * 使用CAS减少线程池中work数量（后29位可以直接整数运算）,失败循环继续尝试直到成功
     */
    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }


    private final BlockingQueue<Runnable> workQueue;


    /**
     * 存放worker线程的集合
     */
    private final HashSet<Worker> workers = new HashSet<Worker>();


    /**
     * 控制ThreadPoolExecutor的全局可重入锁
     */
    private final ReentrantLock mainLock = new ReentrantLock();



    /**
     * 控制ThreadPoolExecutor的全局可重入锁
     */
    private final Condition termination = mainLock.newCondition();


    /**
     * 记录work数量（片段值）
     */
    private int largestPoolSize;


    /**
     * 完成任务数量
     */
    private long completedTaskCount;


    /**
     * work线程构造工厂
     */
    private volatile ThreadFactory threadFactory;


    /**
     * 线程池无法接收新任务时，拒绝执行任务处理器，可以自定义
     */
    private volatile RejectedExecutionHandler handler;


    /**
     * work线程（非核心线程）空闲的时间，大于此时间是被销毁
     */
    private volatile long keepAliveTime;


    /**
     * 是否允许回收核心work线程
     */
    private volatile boolean allowCoreThreadTimeOut;


    /**
     * 线程池中核心work线程的数量。
     */
    private volatile int corePoolSize;


    /**
     * 线程池中允许的最大work数量
     */
    private volatile int maximumPoolSize;

    /** 默认的拒绝策略 **/
    private static final RejectedExecutionHandler defaultHandler =
            new AbortPolicy();

线程池的创建

/**
     * 创建一个线程池,使用默认线程池的拒绝策略和创建work工厂
     * @param corePoolSize 线程池中核心work线程的数量。
     * @param maximumPoolSize 线程池中允许的最大work数量
     * @param keepAliveTime work线程（非核心线程）空闲的时间，大于此时间是被销毁
     * @param unit keepAliveTime的单位。TimeUnit
     * @param workQueue 用来保存等待执行的任务的阻塞队列
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                Executors.defaultThreadFactory(), defaultHandler);
    }

    /**
     * 创建一个线程池,使用默认线程池的拒绝策略
     * @param corePoolSize 线程池中核心work线程的数量。
     * @param maximumPoolSize 线程池中允许的最大work数量
     * @param keepAliveTime work线程（非核心线程）空闲的时间，大于此时间是被销毁
     * @param unit keepAliveTime的单位。TimeUnit
     * @param workQueue 用来保存等待执行的任务的阻塞队列
     * @param threadFactory 创建work工厂
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                threadFactory, defaultHandler);
    }

    /**
     * 创建一个线程池,使用默认的创建work工厂
     * @param corePoolSize 线程池中核心work线程的数量。
     * @param maximumPoolSize 线程池中允许的最大work数量
     * @param keepAliveTime work线程（非核心线程）空闲的时间，大于此时间是被销毁
     * @param unit keepAliveTime的单位。TimeUnit
     * @param workQueue 用来保存等待执行的任务的阻塞队列
     * @param handler 线程池的拒绝策略
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                Executors.defaultThreadFactory(), handler);
    }

    /**
     * 创建一个线程池，
     * @param corePoolSize 线程池中核心work线程的数量。
     * @param maximumPoolSize 线程池中允许的最大work数量
     * @param keepAliveTime work线程（非核心线程）空闲的时间，大于此时间是被销毁
     * @param unit keepAliveTime的单位。TimeUnit
     * @param workQueue 用来保存等待执行的任务的阻塞队列
     * @param threadFactory 创建work工厂
     * @param handler 线程池的拒绝策略
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
                maximumPoolSize <= 0 ||
                maximumPoolSize < corePoolSize ||
                keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }