Spring线程池之一 ThreadPoolTaskExecutor

 

参数

 

线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面会对这7个参数一一解释。

 

一、corePoolSize 线程池核心线程大小

 

线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。

 

二、maximumPoolSize 线程池最大线程数量

 

一个任务被提交到线程池以后，首先会找有没有空闲存活线程，如果有则直接将任务交给这个空闲线程来执行，如果没有则会缓存到工作队列（后面会介绍）中，如果工作队列满了，才会创建一个新线程，然后从工作队列的头部取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列尾部。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。

 

三、keepAliveTime 空闲线程存活时间

 

一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定

 

四、unit 空闲线程存活时间单位

 

keepAliveTime的计量单位

 

五、workQueue 工作队列

 

新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：

 

①ArrayBlockingQueue

 

基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

 

②LinkedBlockingQuene

 

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

 

③SynchronousQuene

 

一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

 

④PriorityBlockingQueue

 

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

 

六、threadFactory 线程工厂

 

创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等

 

七、handler 拒绝策略

 

当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：

 

①CallerRunsPolicy

 

该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。

 

②AbortPolicy

 

该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。

 

③DiscardPolicy

 

该策略下，直接丢弃任务，什么都不做。

 

④DiscardOldestPolicy

 

该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

---

 

 

 

execute()方法详解

 

 

    // Packing and unpacking ctl
    //获取线程池的状态
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    //获取线程池中工作线程数量
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    //根据线程池的状态和工作线程数得到ctl
    private static int ctlOf(int rs, int wc) { return rs | wc; }

execute()方法

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
     
        int c = ctl.get();
        //如果工作线程数小于核心线程数，
        if (workerCountOf(c) < corePoolSize) {
            //执行addWorker,会创建一个核心线程，如果创建失败，重新获取ctl
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果工作线程数大于等于核心线程数，线程池的状态是RUNNING，并且可以添加进队列
        //（RUNNING状态下）如果添加失败，说明是队列已经满了，接着就去创建新的线程，如果大于最大线程数，则执行拒绝策略
        //如果线程池不是RUNNING状态，则执行拒绝策略（当然还会调addWorker进行判断一次）
        if (isRunning(c) && workQueue.offer(command)) {
            //再次获取ctl，进行双重检索（也就是对线程池的状态再次检查一遍）
            int recheck = ctl.get();
            //如果线程池是不是处于RUNNING的状态，那么就会将任务从队列中移除，
            //如果移除失败，则会判断工作线程是否为0 ，如果过为0 就创建一个非核心线程
            //如果移除成功，就执行拒绝策略，因为线程池已经不可用了；
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            //线程池挂了或者大于最大线程数
            reject(command);
    }

 

addWorker()方法

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            //判断线程池的是否可以接收新任务
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                //获取工作线程的数量
                int wc = workerCountOf(c);
                //判断工作线程的数量是否大于等于线程池的上限或者核心或者最大线程数
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //使用cas增加工作线程数
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                //如果添加失败，并且线程池状态发生了改变，重来一遍
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
        //上面的逻辑是考虑是否能够添加线程，如果可以使用cas来增加工作线程数量
        //下面正式启动线程
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            //新建worker
            w = new Worker(firstTask);
            // 获取当前线程
            final Thread t = w.thread;
            if (t != null) {
                //获取重入锁
                final ReentrantLock mainLock = this.mainLock;
                //锁住
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());
                    // rs < SHUTDOWN  -- 状态即为：RUNNING
                    //rs == SHUTDOWN && firstTask == null 
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        //如果线程已经启动，抛出异常
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        //workers是一个HashSet，必须在锁住的情况下，操作
                        workers.add(w);
                        int s = workers.size();
                        //设置largestPoolSize ，标记workerAdded 
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                //如果添加成功，启动线程
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            //启动线程失败,回滚
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }