共计 9119 个字符，预计需要花费 23 分钟才能阅读完成。
相熟 Java 多线程编程的同学都晓得，当咱们线程创立过多时，容易引发内存溢出，因而咱们就有必要应用线程池的技术了。
目录
1 线程池的劣势
2 线程池的应用
3 线程池的工作原理
4 线程池的参数
4.1 工作队列（workQueue）
4.2 线程工厂（threadFactory）
4.3 回绝策略（handler）
5 性能线程池
5.1 定长线程池（FixedThreadPool）
5.2 定时线程池（ScheduledThreadPool）
5.3 可缓存线程池（CachedThreadPool）
5.4 单线程化线程池（SingleThreadExecutor）
5.5 比照
6 总结
参考
1 线程池的劣势
总体来说，线程池有如下的劣势：
（1）升高资源耗费。通过反复利用已创立的线程升高线程创立和销毁造成的耗费。
（2）进步响应速度。当工作达到时，工作能够不须要等到线程创立就能立刻执行。
（3）进步线程的可管理性。线程是稀缺资源，如果无限度的创立，不仅会耗费系统资源，还会升高零碎的稳定性，应用线程池能够进行对立的调配，调优和监控。
2 线程池的应用
线程池的真正实现类是ThreadPoolExecutor，其构造方法有如下 4 种：
1. public ThreadPoolExecutor(int corePoolSize,
2. int maximumPoolSize,
3. long keepAliveTime,
4. TimeUnit unit,
5. BlockingQueue<Runnable> workQueue) {
6. this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
7. Executors.defaultThreadFactory(), defaultHandler);
8. }
10. public ThreadPoolExecutor(int corePoolSize,
11. int maximumPoolSize,
12. long keepAliveTime,
13. TimeUnit unit,
14. BlockingQueue<Runnable> workQueue,
15. ThreadFactory threadFactory) {
16. this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
17. threadFactory, defaultHandler);
18. }
20. public ThreadPoolExecutor(int corePoolSize,
21. int maximumPoolSize,
22. long keepAliveTime,
23. TimeUnit unit,
24. BlockingQueue<Runnable> workQueue,
25. RejectedExecutionHandler handler) {
26. this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
27. Executors.defaultThreadFactory(), handler);
28. }
30. public ThreadPoolExecutor(int corePoolSize,
31. int maximumPoolSize,
32. long keepAliveTime,
33. TimeUnit unit,
34. BlockingQueue<Runnable> workQueue,
35. ThreadFactory threadFactory,
36. RejectedExecutionHandler handler) {
37. if (corePoolSize < 0 ||
38. maximumPoolSize <= 0 ||
39. maximumPoolSize < corePoolSize ||
40. keepAliveTime < 0)
41. throw new IllegalArgumentException();
42. if (workQueue == null || threadFactory == null || handler == null)
43. throw new NullPointerException();
44. this.corePoolSize = corePoolSize;
45. this.maximumPoolSize = maximumPoolSize;
46. this.workQueue = workQueue;
47. this.keepAliveTime = unit.toNanos(keepAliveTime);
48. this.threadFactory = threadFactory;
49. this.handler = handler;
50. }
能够看到，其须要如下几个参数：
- corePoolSize（必须）：外围线程数。默认状况下，外围线程会始终存活，然而当将 allowCoreThreadTimeout 设置为 true 时，外围线程也会超时回收。
- maximumPoolSize（必须）：线程池所能包容的最大线程数。当沉闷线程数达到该数值后，后续的新工作将会阻塞。
- keepAliveTime（必须）：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，外围线程也会超时回收。
- unit（必须）：指定 keepAliveTime 参数的工夫单位。罕用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。
- workQueue（必须）：工作队列。通过线程池的 execute()办法提交的 Runnable 对象将存储在该参数中。其采纳阻塞队列实现。
- threadFactory（可选）：线程工厂。用于指定为线程池创立新线程的形式。
- handler（可选）：回绝策略。当达到最大线程数时须要执行的饱和策略。
线程池的应用流程如下：
1. // 创立线程池
2. ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
3. MAXIMUM_POOL_SIZE,
4. KEEP_ALIVE,
5. TimeUnit.SECONDS,
6. sPoolWorkQueue,
7. sThreadFactory);
8. // 向线程池提交工作
9. threadPool.execute(new Runnable() {
10. @Override
11. public void run() {
12. ... // 线程执行的工作
13. }
14. });
15. // 敞开线程池
16. threadPool.shutdown(); // 设置线程池的状态为 SHUTDOWN，而后中断所有没有正在执行工作的线程
17. threadPool.shutdownNow(); // 设置线程池的状态为 STOP，而后尝试进行所有的正在执行或暂停工作的线程，并返回期待执行工作的列表
3 线程池的工作原理
上面来形容一下线程池工作的原理，同时对下面的参数有一个更深的理解。其工作原理流程图如下：
通过上图，置信大家曾经对所有参数有个理解了。上面再对工作队列、线程工厂和回绝策略做更多的阐明。
4 线程池的参数
4.1 工作队列（workQueue）
工作队列是基于阻塞队列实现的，即采纳生产者消费者模式，在 Java 中须要实现 BlockingQueue 接口。但 Java 曾经为咱们提供了 7 种阻塞队列的实现：
- ArrayBlockingQueue：一个由数组构造组成的有界阻塞队列（数组构造可配合指针实现一个环形队列）。
- LinkedBlockingQueue：一个由链表构造组成的有界阻塞队列，在未指明容量时，容量默认为Integer.MAX_VALUE。
- PriorityBlockingQueue：一个反对优先级排序的无界阻塞队列，对元素没有要求，能够实现 Comparable 接口也能够提供 Comparator 来对队列中的元素进行比拟。跟工夫没有任何关系，仅仅是依照优先级取工作。
- DelayQueue：相似于 PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现Delayed 接口，通过执行时延从队列中提取工作，工夫没到工作取不进去。
- SynchronousQueue：一个不存储元素的阻塞队列，消费者线程调用 take()办法的时候就会产生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就能够拿到这个元素并返回；生产者线程调用 put()办法的时候也会产生阻塞，直到有一个消费者线程生产了一个元素，生产者才会返回。
- LinkedBlockingDeque：应用双向队列实现的有界双端阻塞队列。双端意味着能够像一般队列一样 FIFO（先进先出），也能够像栈一样 FILO（先进后出）。
- LinkedTransferQueue：它是 ConcurrentLinkedQueue、LinkedBlockingQueue 和SynchronousQueue的结合体，然而把它用在 ThreadPoolExecutor 中，和 LinkedBlockingQueue 行为统一，然而是无界的阻塞队列。
留神有界队列和无界队列的区别：如果应用有界队列，当队列饱和时并超过最大线程数时就会执行回绝策略；而如果应用无界队列，因为工作队列永远都能够增加工作，所以设置 maximumPoolSize 没有任何意义。
4.2 线程工厂（threadFactory）
线程工厂指定创立线程的形式，须要实现 ThreadFactory 接口，并实现 newThread(Runnable r) 办法。该参数能够不必指定，Executors 框架曾经为咱们实现了一个默认的线程工厂：
1. /**
2. * The default thread factory.
3. */
4. private static class DefaultThreadFactory implements ThreadFactory {5. private static final AtomicInteger poolNumber = new AtomicInteger(1);
6. private final ThreadGroup group;
7. private final AtomicInteger threadNumber = new AtomicInteger(1);
8. private final String namePrefix;
10. DefaultThreadFactory() {11. SecurityManager s = System.getSecurityManager();
12. group = (s != null) ? s.getThreadGroup() :
13. Thread.currentThread().getThreadGroup();
14. namePrefix = "pool-" +
15. poolNumber.getAndIncrement() +
16. "-thread-";
17. }
19. public Thread newThread(Runnable r) {
20. Thread t = new Thread(group, r,
21. namePrefix + threadNumber.getAndIncrement(),
22. 0);
23. if (t.isDaemon())
24. t.setDaemon(false);
25. if (t.getPriority() != Thread.NORM_PRIORITY)
26. t.setPriority(Thread.NORM_PRIORITY);
27. return t;
28. }
29. }
4.3 回绝策略（handler）
当线程池的线程数达到最大线程数时，须要执行回绝策略。回绝策略须要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 办法。不过 Executors 框架曾经为咱们实现了 4 种回绝策略：
- AbortPolicy（默认）：抛弃工作并抛出 RejectedExecutionException 异样。
- CallerRunsPolicy：由调用线程解决该工作。
- DiscardPolicy：抛弃工作，然而不抛出异样。能够配合这种模式进行自定义的解决形式。
- DiscardOldestPolicy：抛弃队列最早的未解决工作，而后从新尝试执行工作。
5 性能线程池
嫌下面应用线程池的办法太麻烦？其实 Executors 曾经为咱们封装好了 4 种常见的性能线程池，如下：
- 定长线程池（FixedThreadPool）
- 定时线程池（ScheduledThreadPool）
- 可缓存线程池（CachedThreadPool）
- 单线程化线程池（SingleThreadExecutor）
5.1 定长线程池（FixedThreadPool）
创立办法的源码：
1. public static ExecutorService newFixedThreadPool(int nThreads) {
2. return new ThreadPoolExecutor(nThreads, nThreads,
3. 0L, TimeUnit.MILLISECONDS,
4. new LinkedBlockingQueue<Runnable>());
5. }
6. public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
7. return new ThreadPoolExecutor(nThreads, nThreads,
8. 0L, TimeUnit.MILLISECONDS,
9. new LinkedBlockingQueue<Runnable>(),
10. threadFactory);
11. }
- 特点：只有外围线程，线程数量固定，执行完立刻回收，工作队列为链表构造的有界队列。
- 利用场景：控制线程最大并发数。
应用示例：
1. // 1. 创立定长线程池对象 & 设置线程池线程数量固定为 3
2. ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
3. // 2. 创立好 Runnable 类线程对象 & 需执行的工作
4. Runnable task =new Runnable(){5. public void run() {6. System.out.println("执行工作啦");
7. }
8. };
9. // 3. 向线程池提交工作
10. fixedThreadPool.execute(task);
5.2 定时线程池（ScheduledThreadPool）
创立办法的源码：
1. private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
3. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {4. return new ScheduledThreadPoolExecutor(corePoolSize);
5. }
6. public ScheduledThreadPoolExecutor(int corePoolSize) {
7. super(corePoolSize, Integer.MAX_VALUE,
8. DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
9. new DelayedWorkQueue());
10. }
12. public static ScheduledExecutorService newScheduledThreadPool(13. int corePoolSize, ThreadFactory threadFactory) {14. return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
15. }
16. public ScheduledThreadPoolExecutor(int corePoolSize,
17. ThreadFactory threadFactory) {
18. super(corePoolSize, Integer.MAX_VALUE,
19. DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
20. new DelayedWorkQueue(), threadFactory);
21. }
- 特点：外围线程数量固定，非核心线程数量有限，执行完闲置 10ms 后回收，工作队列为延时阻塞队列。
- 利用场景：执行定时或周期性的工作。
应用示例：
1. // 1. 创立 定时线程池对象 & 设置线程池线程数量固定为 5
2. ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
3. // 2. 创立好 Runnable 类线程对象 & 需执行的工作
4. Runnable task =new Runnable(){5. public void run() {6. System.out.println("执行工作啦");
7. }
8. };
9. // 3. 向线程池提交工作
10. scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 提早 1s 后执行工作
11. scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 提早 10ms 后、每隔 1000ms 执行工作
5.3 可缓存线程池（CachedThreadPool）
创立办法的源码：
1. public static ExecutorService newCachedThreadPool() {
2. return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3. 60L, TimeUnit.SECONDS,
4. new SynchronousQueue<Runnable>());
5. }
6. public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
7. return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
8. 60L, TimeUnit.SECONDS,
9. new SynchronousQueue<Runnable>(),
10. threadFactory);
11. }
- 特点：无外围线程，非核心线程数量有限，执行完闲置 60s 后回收，工作队列为不存储元素的阻塞队列。
- 利用场景：执行大量、耗时少的工作。
应用示例：
1. // 1. 创立可缓存线程池对象
2. ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
3. // 2. 创立好 Runnable 类线程对象 & 需执行的工作
4. Runnable task =new Runnable(){5. public void run() {6. System.out.println("执行工作啦");
7. }
8. };
9. // 3. 向线程池提交工作
10. cachedThreadPool.execute(task);
5.4 单线程化线程池（SingleThreadExecutor）
创立办法的源码：
1. public static ExecutorService newSingleThreadExecutor() {
2. return new FinalizableDelegatedExecutorService
3. (new ThreadPoolExecutor(1, 1,
4. 0L, TimeUnit.MILLISECONDS,
5. new LinkedBlockingQueue<Runnable>()));
6. }
7. public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
8. return new FinalizableDelegatedExecutorService
9. (new ThreadPoolExecutor(1, 1,
10. 0L, TimeUnit.MILLISECONDS,
11. new LinkedBlockingQueue<Runnable>(),
12. threadFactory));
13. }
- 特点：只有 1 个外围线程，无非外围线程，执行完立刻回收，工作队列为链表构造的有界队列。
- 利用场景：不适宜并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等。
应用示例：
1. // 1. 创立单线程化线程池
2. ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
3. // 2. 创立好 Runnable 类线程对象 & 需执行的工作
4. Runnable task =new Runnable(){5. public void run() {6. System.out.println("执行工作啦");
7. }
8. };
9. // 3. 向线程池提交工作
10. singleThreadExecutor.execute(task);
5.5 比照
6 总结
Executors 的 4 个性能线程池尽管不便，但当初曾经不倡议应用了，而是倡议间接通过应用 ThreadPoolExecutor 的形式，这样的解决形式让写的同学更加明确线程池的运行规定，躲避资源耗尽的危险。
其实 Executors 的 4 个性能线程有如下弊病：
- FixedThreadPool和SingleThreadExecutor：次要问题是沉积的申请解决队列均采纳LinkedBlockingQueue，可能会消耗十分大的内存，甚至 OOM。
- CachedThreadPool和ScheduledThreadPool：次要问题是线程数最大数是Integer.MAX_VALUE，可能会创立数量十分多的线程，甚至 OOM。
正文完