线程池归纳

总括：

 

线程池中的线程创建线程池的时候没有创建，只有在具体执行任务的时候，才检查是否达到核心线程数，没有就创建---类似延时加载

核心线程消耗不了就放入队列，之后新进入的任务放入队列，线程执行任务优先从队列获取

队列满了之后，核心线程还是消费不过来，启用最大线程数，一旦启用最大线程数，直到队列没有积压任务，非核心线程空闲超时自动回收最后留下核心线程数--新创建核心线程外的线程数

多线程的3中方法就是创建线程任务的方法，线程任务放入线程中执行

线程池中的start，最终调用的还是任务中的run方法

线程池源码中worker相当于thread，任务队列中的队列相当于任务run方法

线程池执行线程的时候抛异常时就会删除旧的线程，重新建立新的线程

 

FixedThreadPool 中的变量即使核心线程数，也是最大线程数

 

 public static ExecutorService newFixedThreadPool(int nThreads) {

        return new ThreadPoolExecutor(nThreads, nThreads,

                                      0L, TimeUnit.MILLISECONDS,

                                      new LinkedBlockingQueue<Runnable>());

    }

 

 

 

 

带着几个问题进入源码分析:

1. 线程池是什么时候创建线程的？

2. 任务runnable task是先放到core到maxThread之间的线程，还是先放到队列？

3. 队列中的任务是什么时候取出来的？

4. 什么时候会触发reject策略？

5. core到maxThread之间的线程什么时候会die?

6. task抛出异常，线程池中这个work thread还能运行其他任务吗?

 

先写一段基础代码，进入分析

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

public static void main(String[] args) {           ExecutorService executorService = new ThreadPoolExecutor(2, 5, 0, TimeUnit.DAYS,                 new ArrayBlockingQueue<>(1), new ThreadFactory() {             @Override             public Thread newThread(Runnable r) {                 Thread thread = new Thread(r); //                thread.setDaemon(true);                 return thread;             }         });         // 对象创建后，线程实际还没开始创建           // 执行execute时，检查当前池中线程数大小是否小于core number, 如果是，则创建新线程         executorService.execute(() -> {             System.out.println("任务1@" + Thread.currentThread().getName());             sleepTime();             System.out.println(1);         });           //检查当前池中线程数大小是否小于core number, 如果是，则创建新线程         executorService.execute(() -> {             System.out.println("任务2@" + Thread.currentThread().getName());             sleepTime();             System.out.println(2);         });           // 检查当前池中线程数大小是否小于core number, 如果不是，则偿试放入队列         // 这个任务是加到队列去的, 注意队列大小只有1，         // TODO 队列中的任务是什么时候取出来的？   任务1或者2结束后所占用的线程 会运行队列中的任务，这个任务是在最后才运行，比4运行的还晚         executorService.execute(() -> {             System.out.println("任务3@" + Thread.currentThread().getName());             sleepTime();             System.out.println(3);         });           // 检查当前池中线程数大小是否小于core number, 如果不是,则偿试放入队列,放入队列也失败，则增加新的worker线程         // 这个任务是加到core以外的新线程去的         executorService.execute(() -> {             System.out.println("任务4@" + Thread.currentThread().getName());             sleepTime();             System.out.println(4);         });     }

　　

注意第3行，创建一个核心池2, 最大池5, 队列为1的线程池

至少在new ThreadPoolExecutor()时，Thread对象并没有初始化. 这里仅仅指定了几个初始参数

 

执行第一个execute时，进入调试jdk源码

 代码块1

第一个if， 判断如果当前线程数小于corePoolSize, 则创建新的核心worker对象（Worker中指向Thread对象，保持引用，保证不会被GC回收）

     我们的示例代码中，第1和第2个任务都是这样创建出线程的

第二个if,   判断如果当前线程数大于corePoolSize, 并偿试放入队列 workQueue.offer(command) , 放入成功后等待线程池调度【见后面的getTask()】

     示例代码中，第3个任务是这样等待调度的，最后才执行

第三个if,  偿试放入队列 workQueue.offer(command) 失败， 增加一个非core的线程

     示例代码中，第4个任务是这样开始的

 

 

然后再看addWorker（）的过程

 

new Worker构造和线程启动

线程启动后，又做了哪些工作：

异常分析

没抛异常时，此线程会一直在while（task !=null || (task = getTask())!=null）中跑

那么有异常时，再看一下processWorkerExit

 

可以 看出，有异常时 旧的worker会被删除（GC回收），再创建新的Worker， 即有异常时 旧worker不可能再执行新的任务

 

 

总结：

 

Q. 线程池是什么时候创建线程的？

A.任务提交的时候

Q.任务runnable task是先放到core到maxThread之间的线程，还是先放到队列？

A.先放队列!!!

Q. 队列中的任务是什么时候取出来的？

A. worker中 runWorker() 一个任务完成后，会取下一个任务

Q. 什么时候会触发reject策略？

A.队列满并且maxthread也满了， 还有新任务，默认策略是reject

Q. core到maxThread之间的线程什么时候会die?

A.  没有任务时，或者抛异常时。   

   core线程也会die的，core到maxThread之间的线程有可能会晋升到core线程区间，

   core max只是个计数，线程并不是创建后就固定在一个区间了

Q. task抛出异常，线程池中这个work thread还能运行其他任务吗?

A. 不能。 但是会创建新的线程, 新线程可以运行其他task。

对于 schedulerThreadPoolExecutor?   虽然有新线程，但是旧的循环任务不会再继续执行了， 开发实践推荐任务中捕获所有Exception