备案控制台
开发者社区 开发与运维 文章 正文

五分钟带你玩转多线程（二）带你了解线程池

2021-12-07 107
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。

 

熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。

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. }
9. 
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. }
19. 
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. }
29. 
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. }

可以看到，其需要如下几个参数：

  1. corePoolSize（必需）：核心线程数。默认情况下，核心线程会一直存活，但是当将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。
  2. maximumPoolSize（必需）：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。
  3. keepAliveTime（必需）：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。
  4. unit（必需）：指定keepAliveTime参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。
  5. workQueue（必需）：任务队列。通过线程池的execute()方法提交的Runnable对象将存储在该参数中。其采用阻塞队列实现。
  6. threadFactory（可选）：线程工厂。用于指定为线程池创建新线程的方式。
  7. handler（可选）：拒绝策略。当达到最大线程数时需要执行的饱和策略。

线程池的使用流程如下：

1. // 创建线程池
2. Executor 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 线程池的工作原理

下面来描述一下线程池工作的原理，同时对上面的参数有一个更深的了解。其工作原理流程图如下：

image.png

通过上图，相信大家已经对所有参数有个了解了。下面再对任务队列、线程工厂和拒绝策略做更多的说明。

4 线程池的参数

4.1 任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在Java中需要实现BlockingQueue接口。但Java已经为我们提供了7种阻塞队列的实现：

  1. ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。
  2. LinkedBlockingQueue： 一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为Integer.MAX_VALUE。
  3. PriorityBlockingQueue： 一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现Comparable接口也可以提供Comparator来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。
  4. DelayQueue：类似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现Delayed接口，通过执行时延从队列中提取任务，时间没到任务取不出来。
  5. SynchronousQueue：   一个不存储元素的阻塞队列，消费者线程调用take()方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就可以拿到这个元素并返回；生产者线程调用put()方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。
  6. LinkedBlockingDeque： 使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样FIFO（先进先出），也可以像栈一样FILO（先进后出）。
  7. 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;
9. 
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.     }
18. 
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种拒绝策略：

  1. AbortPolicy（默认）：丢弃任务并抛出RejectedExecutionException异常。
  2. CallerRunsPolicy：由调用线程处理该任务。
  3. DiscardPolicy：丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。
  4. DiscardOldestPolicy：丢弃队列最早的未处理任务，然后重新尝试执行任务。

5 功能线程池

嫌上面使用线程池的方法太麻烦？其实Executors已经为我们封装好了4种常见的功能线程池，如下：

  1. 定长线程池（FixedThreadPool）
  2. 定时线程池（ScheduledThreadPool ）
  3. 可缓存线程池（CachedThreadPool）
  4. 单线程化线程池（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;
2. 
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. }
11. 
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);

单线程化线程池（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 对比

image.png

6 总结

Executors的4个功能线程池虽然方便，但现在已经不建议使用了，而是建议直接通过使用ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

其实Executors的4个功能线程有如下弊端：

  1. FixedThreadPool和SingleThreadExecutor：主要问题是堆积的请求处理队列均采用LinkedBlockingQueue，可能会耗费非常大的内存，甚至OOM。
  2. CachedThreadPool和ScheduledThreadPool：主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。


文章标签：
Java
监控
数据库
缓存
存储
关键词：
多线程线程
线程线程池
小鲍侃java
目录
相关文章
落雨便归尘
|
1天前
|
存储 Linux C语言
c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写
本文介绍了C++中使用C语言的pthread库实现多线程编程。`pthread_create`用于创建新线程，`pthread_self`返回当前线程ID。示例展示了如何创建线程并打印线程ID，强调了线程同步的重要性，如使用`sleep`防止主线程提前结束导致子线程未执行完。`pthread_exit`用于线程退出，`pthread_join`用来等待并回收子线程，`pthread_detach`则分离线程。文中还提到了线程取消功能，通过`pthread_cancel`实现。这些基本操作是理解和使用C/C++多线程的关键。
落雨便归尘
12 7
梦回故国楼台梦
|
3天前
|
安全 Java
【极客档案】Java 线程：解锁生命周期的秘密，成为多线程世界的主宰者！
【6月更文挑战第19天】Java多线程编程中，掌握线程生命周期是关键。创建线程可通过继承`Thread`或实现`Runnable`，调用`start()`使线程进入就绪状态。利用`synchronized`保证线程安全，处理阻塞状态，注意资源管理，如使用线程池优化。通过实践与总结，成为多线程编程的专家。
梦回故国楼台梦
14 3
梦回故国楼台梦
|
3天前
|
Java 开发者
告别单线程时代！Java 多线程入门：选继承 Thread 还是 Runnable？
【6月更文挑战第19天】在Java中，面对多任务需求时，开发者可以选择继承`Thread`或实现`Runnable`接口来创建线程。`Thread`继承直接但限制了单继承，而`Runnable`接口提供多实现的灵活性和资源共享。多线程能提升CPU利用率，适用于并发处理和提高响应速度，如在网络服务器中并发处理请求，增强程序性能。不论是选择哪种方式，都是迈向高效编程的重要一步。
梦回故国楼台梦
11 2
梦回故国楼台梦
|
3天前
|
Java 开发者
震惊！Java多线程的惊天秘密：你真的会创建线程吗？
【6月更文挑战第19天】Java多线程创建有两种主要方式：继承Thread类和实现Runnable接口。继承Thread限制了多重继承，适合简单场景；实现Runnable接口更灵活，可与其它继承结合，是更常见选择。了解其差异对于高效、健壮的多线程编程至关重要。
梦回故国楼台梦
13 2
东方睿赢
|
5天前
|
Java 程序员
Java多线程编程是指在一个进程中创建并运行多个线程，每个线程执行不同的任务，并行地工作，以达到提高效率的目的
【6月更文挑战第18天】Java多线程提升效率，通过synchronized关键字、Lock接口和原子变量实现同步互斥。synchronized控制共享资源访问，基于对象内置锁。Lock接口提供更灵活的锁管理，需手动解锁。原子变量类（如AtomicInteger）支持无锁的原子操作，减少性能影响。
东方睿赢
18 3
梦回故国楼台梦
|
3天前
|
Java
JAVA多线程深度解析：线程的创建之路，你准备好了吗？
【6月更文挑战第19天】Java多线程编程提升效率，通过继承Thread或实现Runnable接口创建线程。Thread类直接继承启动简单，但限制多继承；Runnable接口实现更灵活，允许类继承其他类。示例代码展示了两种创建线程的方法。面对挑战，掌握多线程，让程序高效运行。
梦回故国楼台梦
10 1
梦回故国楼台梦
|
3天前
|
Java 调度
【实战指南】Java多线程高手秘籍：线程生命周期管理，掌控程序命运的钥匙！
【6月更文挑战第19天】Java多线程涉及线程生命周期的五个阶段：新建、就绪、运行、阻塞和死亡。理解这些状态转换对性能优化至关重要。线程从新建到调用`start()`变为就绪，等待CPU执行。获得执行权后进入运行状态，执行`run()`。遇到阻塞如等待锁时，进入阻塞状态。完成后或被中断则死亡。管理线程包括合理使用锁、利用线程池、处理异常和优雅关闭线程。通过控制这些，能编写更高效稳定的多线程程序。
梦回故国楼台梦
8 1
绿水长流*z
|
9天前
|
Java API
详细探究Java多线程的线程状态变化
Java多线程的线程状态主要有六种：新建（NEW）、可运行（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、超时等待（TIMED_WAITING）和终止（TERMINATED）。线程创建后处于NEW状态，调用start()后进入RUNNABLE状态，表示准备好运行。当线程获得CPU资源，开始执行run()方法时，它处于运行状态。线程可以因等待锁或调用sleep()等方法进入BLOCKED或等待状态。线程完成任务或发生异常后，会进入TERMINATED状态。
绿水长流*z
13 5
绿水长流*z
|
9天前
|
存储 安全 Java
Java多线程中线程安全问题
Java多线程中的线程安全问题主要涉及多线程环境下对共享资源的访问可能导致的数据损坏或不一致。线程安全的核心在于确保在多线程调度顺序不确定的情况下，代码的执行结果始终正确。常见原因包括线程调度随机性、共享数据修改以及原子性问题。解决线程安全问题通常需要采用同步机制，如使用synchronized关键字或Lock接口，以确保同一时间只有一个线程能够访问特定资源，从而保持数据的一致性和正确性。
绿水长流*z
11 1
goyeer
|
19天前
|
开发框架 监控 Java
【.NET Core】多线程之线程池（ThreadPool）详解（二）
【.NET Core】多线程之线程池（ThreadPool）详解（二）
goyeer
31 3

热门文章

最新文章

  • 1
    案例分析｜线程池相关故障梳理&总结
  • 2
    Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
  • 3
    【JAVA】Java 中什么叫单例设计模式？请用 Java 写出线程安全的单例模式
  • 4
    Python并发编程：解析异步IO与多线程
  • 5
    【JAVA】线程的run()和start()有什么区别？
  • 6
    高级主题：Visual Basic 中的多线程和并发编程
  • 7
    高德地图爬虫实践：Java多线程并发处理策略
  • 8
    Python 多线程编程实战：threading 模块的最佳实践
  • 9
    Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
  • 10
    JavaSE&多线程&线程池
  • 1
    Springboot启动的时候初始化的线程池默认配置tomcat
    33
  • 2
    SpringBoot实现多线程定时任务动态定时任务配置文件配置定时任务
    316
  • 3
    Python开启线程和线程池的方法
    26
  • 4
    【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
    101
  • 5
    【Qt 底层之事件驱动系统】深入理解 Qt 事件机制：主事件循环与工作线程的交互探究，包括 QML 的视角
    300
  • 6
    【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
    60
  • 7
    线程同步与IPC：单进程多线程环境下的选择与权衡
    82
  • 8
    【Linux 系统标准 进程资源】Linux 创建一个最基本的进程所需的资源分析,以及线程资源与之的差异
    143
  • 9
    【软件设计师备考 专题 】操作系统的内核（中断控制）、进程、线程概念
    92
  • 10
    【ffmpeg音视频同步】解决ffmpeg音视频中多线程之间的数据同步问题
    95

    • 相关电子书

    更多
  • 多IO线程优化版
  • 多线程
  • 低代码开发师（初级）实战教程
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考