线程池

精彩文章

精彩文章

java线程池的主角是ThreadPoolExecutor,其实说线程池有啥好处，大部分好处都可以参考各种池，比如数据库连接池。

一、参数介绍

1. corePoolSize: 核心线程池的大小，这个大小就是常驻内存的线程，可以循环使用的，该线程属于核心线程
2. workQueue：如果超过了 corePoolSize，这个时候代表任务太多了，人不够，所以只能让这些任务先进入等待队列。
3. maximumPoolSize：这个参数是最迷惑人的，这个参数和workQueue参数是有关联的，如果workQueue是无界队列，那么maximumPoolSize这参数就没有作用，只有是有界队列的时候，当该队列满的时候，如果任务数（不包含队列中的）小于maximumPoolSize，那么会里面创建线程（属于非核心线程）进行执行。就类似于突然给你加人了，这些人还只做新的任务，如果大于maximumPoolSize，那么就会触发拒绝策略
4. keepAliveTime：这个参数也是很多人理解错的，这个参数是针对非核心线程的，当非核心线程做完工作，就会处于空闲状态，keepAliveTime就是处于空闲的最大时间
5. unit：这个是和keepAliveTime联动的，是该参数的单位
6. threadFactory：线程工厂，典型的设计模式工厂方法的应用
7. handler：拒绝策略

二、源码分析

ThreadPoolExecutor的execute方法写的非常清晰，很友好

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get(); //该参数即保存了线程的个数，也保存线程的状态
        
        //第一步判断现在线程数量是否小于核心线程池个数
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //大于核心线程的情况下，开始执行加入队列，加入成功后进行doble check
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果加入队列不成功，那么就会判断和maximumPoolSize参数比较
        else if (!addWorker(command, false))
            reject(command);
    }

2.1 addWork

上面三个判断都是围绕改方法进行的，所以这个方法兼容性很大

1. 状态检查

retry:for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // 检查线程池是否关闭和检查阻塞队列是否为空.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                //如果是核心线程就和corePoolSize比较，非核心线程就和maximumPoolSize 比较
                if (wc >= CAPACITY ||   
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))//cas的方式增加workCount，其实就是线程数量
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

状态图：

第一个检查：线程池不接受新的work的情况。

1. 线程池处于 stop tidying terminate状态（>=shutdown）
2. rs == SHUTDOWN &&firstTask == null && ! workQueue.isEmpty() 这段话的意思是线程池处于shutdown状态，但是阻塞队列又不为空，而且即将添加的任务是空任务，所以下面接着是处理 阻塞队列的内容。这是一种特殊的状态，当调用shutdown的时候，线程池处于shutdown状态，这个时候不接受新的线程，但是要继续处理正在运行的和阻塞队列中的任务。所以这个条件是可以继续addWork，上面是条件是取反。

第二个检查：如果是核心线程，那么在调用addWork方法的时候在外面已经判断了肯定小于corePoolize，这里面再次判断的目的就是因为多线程争夺共享资源，而且他是争取用最小的锁来进行更新线程数量，这里采用的CAS。

2. 创建work，并且运行

w = new Worker(firstTask);

Worker(Runnable firstTask) {
   setState(-1); // inhibit interrupts until runWorker
   this.firstTask = firstTask;
   this.thread = getThreadFactory().newThread(this);
}

2.2 runWork

这方法整体没什么，只是有个点不太理解
他先调用，unlock，这个方法怎么会允许中断吗？

 w.unlock(); // allow interrupts

然后就是判断是否有中断，相应中断

 if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();

后面就是真正的执行了