【JUC】如何理解线程池？第四种使用线程的方式

线程池的概念

线程池的主要工作的控制运行的线程的数量，处理过程种将任务放在队列，线程创建后再启动折现任务，如果线程数量超过了最大的数量，则超过部分的线程排队等待，直到其他线程执行完毕后，从队列种取出任务来执行。

处理流程：

1.线程池判断核心线程池的线程是否全部在执行任务？

　　1.1 不是：创建一个新的工作线程执行任务。

　　1.2 是：

　　　　2. 线程池判断工作队列是否已经满了？

　　　　　　2.1 没有满：将新提交的任务存储在工作队列中。

　　　　　　2.2 满了：

　　　　　　　　3. 线程池判断线程池的线程是否都在工作？

　　　　　　　　　　3.1 是：交由饱和策略来处理这个任务。

　　　　　　　　　　3.2 不是：创建一个新的工作线程来执行任务。　　　　　　　

特点：线程复用、控制最大并发数、管理线程。

线程池的优势

1. 降低资源消耗，通过重复利用已经创建的线程，降低了线程创建和销毁产生的消耗。

2. 提高响应速度，任务到达时，任务不需要等待线程创建就能立即执行。

3. 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行同一的分配、调优和监控。

线程池的使用

 Java线程池是通过Executor框架实现的，该框架中用到了Executor、Executors、ExecutorService和ThreadPoolExecutor类。

 具体使用示例：

 1     public static void fixedThreadPool() {
 2         ExecutorService threadPool = Executors.newFixedThreadPool(5);//固定线程
 3         try {
 4             for (int i = 0; i < 10; i++) {
 5                 threadPool.execute(()->{
 6                     System.out.println(Thread.currentThread().getName());
 7                 });
 8             }
 9         }catch (Exception e){
10             e.printStackTrace();
11         }finally {
12             threadPool.shutdown();
13         }
14     }

输出结果

pool-1-thread-2
pool-1-thread-4
pool-1-thread-2
pool-1-thread-5
pool-1-thread-1
pool-1-thread-3
pool-1-thread-5
pool-1-thread-1
pool-1-thread-2
pool-1-thread-4

View Code

线程池的源码及重要参数

Executors.newFixedThreadPool(int)

固定线程数，适用场景：执行长期任务，性能好。

1     public static ExecutorService newFixedThreadPool(int nThreads) {
2         return new ThreadPoolExecutor(nThreads, nThreads,
3                                       0L, TimeUnit.MILLISECONDS,
4                                       new LinkedBlockingQueue());
5     }

Executors.newSingleThreadExecutor()

一池一个线程，使用场景：一个任务接一个任务执行的时候。

1     public static ExecutorService newSingleThreadExecutor() {
2         return new FinalizableDelegatedExecutorService
3             (new ThreadPoolExecutor(1, 1,
4                                     0L, TimeUnit.MILLISECONDS,
5                                     new LinkedBlockingQueue()));
6     }

Executors.newCachedThreadPool()

N个线程，带缓存，适用场景：执行很多短期异步的小程序或者负载较轻的服务器。

1     public static ExecutorService newCachedThreadPool() {
2         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3                                       60L, TimeUnit.SECONDS,
4                                       new SynchronousQueue());
5     }

ThreadPoolExecutor

ThreadPoolExecutor的执行示意图：

 

 

1. corePoolSize：线程池中的常驻核心线程数

2. maximumPoolSize：线程池能够容纳同时执行的最大线程数，必须大于等于1【扩容的上限】。如果工作队列满了，core也满了的时候，线程池会扩容，直到达到maximumPoolSize（新来的任务会直接抢占扩容线程，不进入工作队列，工作队列中的任务继续等待）。

 1     public static void main(String[] args) {
 2         ExecutorService threadPool = new ThreadPoolExecutor(
 3                 2, //corePoolSize
 4                 5, //maximumPoolSize
 5                 100L, //keepAliveTime
 6                 TimeUnit.SECONDS,
 7                 new LinkedBlockingDeque<>(3),
 8                 Executors.defaultThreadFactory(),
 9                 new ThreadPoolExecutor.AbortPolicy());//N个线程带缓存
10         try {
11             for (int i = 1; i <= 6; i++) {
12                 final int tmp = i;
13                 threadPool.execute(()->{
14                     System.out.println(Thread.currentThread().getName()+"线程"+"，执行任务"+tmp);
15                     try {
16                         TimeUnit.SECONDS.sleep(4);
17                     } catch (InterruptedException e) {
18                         e.printStackTrace();
19                     }
20                 });
21             }
22         }catch (Exception e){
23             e.printStackTrace();
24         }finally {
25             threadPool.shutdown();
26         }
27     }

输出结果：

pool-1-thread-2线程，执行任务2
pool-1-thread-3线程，执行任务6
pool-1-thread-1线程，执行任务1
pool-1-thread-3线程，执行任务3
pool-1-thread-2线程，执行任务4
pool-1-thread-1线程，执行任务5

View Code

当线程池中有2个核心线程时，线程1和2正在执行任务1和2，任务3、4、5在工作队列中等候，此时工作队列满了，core也满了的时候，且core< maximumPoolSize，任务6的出现引起线程池的扩容，任务6在3、4、5执行任务前进行了抢占。所以从输出结果可以看出新来的任务会直接抢占新扩容的线程。

3. keepAliveTime：多余的空闲线程的存活时间。当前线程数超过corePoolSize的时候，空闲时间达到keepAliveTime时，多余的空闲线程会被销毁直到剩下corePoolSize的数量的线程。

4. unit：keepAliveTime的单位

5. workQueue：（阻塞队列）工作队列，任务等待区，被提交但是没有被执行的任务。

6. threadFactory：线程工厂，用于创建线程，一般用默认即可。

7. handler：拒绝策略。当队列满了并且工作线程大于线程池的最大线程数的时候触发拒绝策略。

 

5个参数的构造函数

1     public ThreadPoolExecutor(int corePoolSize,
2                               int maximumPoolSize,
3                               long keepAliveTime,
4                               TimeUnit unit,
5                               BlockingQueue workQueue) {
6         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, 7  Executors.defaultThreadFactory(), defaultHandler); 8 }

7个参数的构造函数

 1     public ThreadPoolExecutor(int corePoolSize,
 2                               int maximumPoolSize,
 3                               long keepAliveTime,
 4                               TimeUnit unit,
 5                               BlockingQueue workQueue,
 6                               ThreadFactory threadFactory,
 7                               RejectedExecutionHandler handler) {
 8         if (corePoolSize < 0 ||
 9             maximumPoolSize <= 0 ||
10             maximumPoolSize < corePoolSize ||
11             keepAliveTime < 0)
12             throw new IllegalArgumentException();
13         if (workQueue == null || threadFactory == null || handler == null)
14             throw new NullPointerException();
15         this.acc = System.getSecurityManager() == null ?
16                 null :
17                 AccessController.getContext();
18         this.corePoolSize = corePoolSize;
19         this.maximumPoolSize = maximumPoolSize;
20         this.workQueue = workQueue;
21         this.keepAliveTime = unit.toNanos(keepAliveTime);
22         this.threadFactory = threadFactory;
23         this.handler = handler;
24     }

线程池的底层工作原理及源码

ThreadPoolExecutor执行execute方法分下面4种情况。

1）如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）。

2）如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。

3）如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务（注意，执行这一步骤需要获取全局锁）。

4）如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。

 

ThreadPoolExecutor采取上述步骤的总体设计思路，是为了在执行execute()方法时，尽可能地避免获取全局锁（那将会是一个严重的可伸缩瓶颈）。在ThreadPoolExecutor完成预热之后（当前运行的线程数大于等于corePoolSize），几乎所有的execute()方法调用都是执行步骤2，而步骤2不需要获取全局锁。

 

 1     public void execute(Runnable command) {
 2         if (command == null)
 3             throw new NullPointerException();
 4         int c = ctl.get();
 5         //如果线程数小于核心线程数，创建线程执行任务
 6         if (workerCountOf(c) < corePoolSize) {
 7             if (addWorker(command, true))
 8                 return;
 9             c = ctl.get();
10         }
11         //如果线程数大于等于核心线程数或线程创建失败，当前任务加入工作队列
12         if (isRunning(c) && workQueue.offer(command)) {
13             int recheck = ctl.get();
14             if (! isRunning(recheck) && remove(command))
15                 reject(command);
16             else if (workerCountOf(recheck) == 0)
17                 addWorker(null, false);
18         }
19         //如果线程数不处于运行中或人物失效无法放入队列，
20         //且当前线程数量小于最大允许的线程数，则创建一个线程执行任务
21         else if (!addWorker(command, false))
22             reject(command);
23     }

 

工作线程：线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会循环获取工作队列里的任务来执行。我们可以从Worker类的run()方法里看到。

 1     public void run() {
 2         runWorker(this);
 3     }
 4 
 5     final void runWorker(Worker w) {
 6         Thread wt = Thread.currentThread();
 7         Runnable task = w.firstTask;
 8         w.firstTask = null;
 9         w.unlock(); // allow interrupts
10         boolean completedAbruptly = true;
11         try {//循环获取工作队列里的任务执行
12             while (task != null || (task = getTask()) != null) {
13                 w.lock();
14                 // If pool is stopping, ensure thread is interrupted;
15                 // if not, ensure thread is not interrupted.  This
16                 // requires a recheck in second case to deal with
17                 // shutdownNow race while clearing interrupt
18                 if ((runStateAtLeast(ctl.get(), STOP) ||
19                      (Thread.interrupted() &&
20                       runStateAtLeast(ctl.get(), STOP))) &&
21                     !wt.isInterrupted())
22                     wt.interrupt();
23                 try {
24                     beforeExecute(wt, task);
25                     Throwable thrown = null;
26                     try {
27                         task.run();
28                     } catch (RuntimeException x) {
29                         thrown = x; throw x;
30                     } catch (Error x) {
31                         thrown = x; throw x;
32                     } catch (Throwable x) {
33                         thrown = x; throw new Error(x);
34                     } finally {
35                         afterExecute(task, thrown);
36                     }
37                 } finally {
38                     task = null;
39                     w.completedTasks++;
40                     w.unlock();
41                 }
42             }
43             completedAbruptly = false;
44         } finally {
45             processWorkerExit(w, completedAbruptly);
46         }
47     }

线程池的拒绝策略（RejectedExecutionHandler）

当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。在JDK 1.5中Java线程池框架提供了以下4种策略。
1. AbortPolicy：直接抛出异常。RejectedExecutionException
2. CallerRunsPolicy：只用调用者所在线程来运行任务。不抛弃任务，也不抛出异常，将任务回退到调用者。

例如：任务数 > maximumPoolSize+Queue.capacity=8的时候拒绝任务9和10，任务回退给调用者，示例中的调用者就是main线程。

pool-1-thread-1线程，执行任务1
main线程，执行任务9
pool-1-thread-3线程，执行任务6
pool-1-thread-2线程，执行任务2
pool-1-thread-5线程，执行任务8
pool-1-thread-4线程，执行任务7
main线程，执行任务10
pool-1-thread-3线程，执行任务3
pool-1-thread-1线程，执行任务5
pool-1-thread-5线程，执行任务4

3. DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
4. DiscardPolicy：不处理，丢弃掉。

任务队列（runnableTaskQueue）

1. ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序。
2. LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
3. SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于Linked-BlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

在实际开发中选择那种线程池？

三种：单一/固定数/可变，都不能用。为什么不用？

在实际的开发中线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。

因为不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者过度切换的问题。

线程池不允许适用Executors去创建，而是通过ThreadPoolExecutor的方式，可以避免资源耗尽的风险。

Executors中的线程池对象存在的问题：

1. FixedThreadPool和SingleThreadPool：允许请求队列的长度为Integer.MAX_VALUE，可能会堆积大量请求，导致OOM

2. CachedThreadPool和ScheduledThreadPool：允许创建线程数量为Integer.MAX_VALUE，可能会创建大量请求，导致OOM

所以应该选择自定义线程池。

如何配置自定义的线程池参数？

首先查询服务器是几核的？Runtime.getRuntime().availableProcessors();

1. CPU密集型

任务需要大量的运算，而没有阻塞，CPU一直全速运行，CPU密集任务只有在真正的多核CPU上才可能得到加速。（通过多线程）

应该配置尽可能少的线程数量：CPU核数+1个线程的线程池

2. IO密集型

IO密集型任务并不是一直执行任务，则应配置尽可能多的线程，

CPU核数 * 2

CPU核数 / 1 - 阻塞系数（0.8~0.9）

补充：CPU密集 & IO密集

CPU密集型，又称计算密集型任务。它的特点是要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种计算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低，所以，要最高效地利用CPU，计算密集型任务同时进行的数量应当等于CPU的核心数。计算密集型任务由于主要消耗CPU资源，因此，代码运行效率至关重要。

IO密集型，涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成（因为IO的速度远远低于CPU和内存的速度）。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是IO密集型任务，比如Web应用。IO密集型任务执行期间，99%的时间都花在IO上，花在CPU上的时间很少。