Java 线程池ThreadPoolExecutor

最新推荐文章于 2024-09-25 09:35:04 发布
最新推荐文章于 2024-09-25 09:35:04 发布
阅读量2.2w 收藏 17
点赞数 1
分类专栏： Java 文章标签： java 任务 exception object hashmap string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abing37/article/details/4506759
版权

 

Java 线程池 ThreadPoolExecutor.

 

JDK1.5 开始关于多线程加了很多特性。如：

ConcurrentHashMap: 放弃使用公用锁同步每一个方法，使用了更细化的锁机制，分离锁。对于大数据量的 HashMap 同步操作效率有了较大提升。

CopyOnWriteArrayList: 是同步 List 的一个并发替代品。其线程安全性来源于这样一个事实：只要有效的不可变对象被正确发布，那么访问它将不再需要更多的同步。在每次需要修改时它们会创建并重新发布一个信的容器拷贝，以此来实现可变性。

增加了 Callable 和 Future 。 Callable 是 runnable 的一个可选替代。我们之前用的 Runnable 是不能返回状态的，而 Callable 是可以返回状态，返回的状态保存在泛型 Future<T> 里。

JDK1.5 里面还包含了一个重要的特性就是线程池。通过查看代码可以看出主要都是由大师 Doug Lea 来完成的。本文主要介绍线程池 ThreadPoolExecutor 的使用。

 

JDK1.5 的线程池由 Executor 框架提供。 Executor 框架将处理请求任务的提交和它的执行解耦。可以制定执行策略。在线程池中执行线程可以重用已经存在的线程，而不是创建新的线程，可以在处理多请求时抵消线程创建、消亡产生的开销。如果线程池过大，会导致内存的高使用量，还可能耗尽资源。如果过小，会由于存在很多的处理器资源未工作，对吞吐量造成损失。

由于内容较多没有一一研究，只看了较常用的 ThreadPoolExecutor ，所以在这里做个介绍。 ThreadPoolExecutor 的继承关系如下。

Executor->ExecutorService->AbstractExecutorService->ThreadPoolExecutor

核心池大小 (core pool size) 、最大池的大小 (maximum pool size) 、存活时间 (keep-alive time) 共同管理着线程的创建和销毁。

线程池类为 java.util.concurrent.ThreadPoolExecutor ，常用构造方法为：

/**

* Creates a new <tt> ThreadPoolExecutor </tt> with the given initial

* parameters.

*

* @param corePoolSize the number of threads to keep in the

* pool, even if they are idle.

* @param maximumPoolSize the maximum number of threads to allow in the

* pool.

* @param keepAliveTime when the number of threads is greater than

* the core, this is the maximum time that excess idle threads

* will wait for new tasks before terminating.

* @param unit the time unit for the keepAliveTime

* argument.

* @param workQueue the queue to use for holding tasks before they

* are executed. This queue will hold only the <tt> Runnable </tt>

* tasks submitted by the <tt> execute </tt> method.

* @param handler the handler to use when execution is blocked

* because the thread bounds and queue capacities are reached.

* @throws IllegalArgumentException if corePoolSize, or

* keepAliveTime less than zero, or if maximumPoolSize less than or

* equal to zero, or if corePoolSize greater than maximumPoolSize.

* @throws NullPointerException if <tt> workQueue </tt>

* or <tt> handler </tt> are null.

*/

public ThreadPoolExecutor( int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue<Runnable> workQueue,

RejectedExecutionHandler handler) {

this (corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

Executors. defaultThreadFactory (), handler);

}

corePoolSize ： 线程池维护线程的最少数量，哪怕是空闲的。

maximumPoolSize ：线程池维护线程的最大数量。

keepAliveTime ： 线程池维护线程所允许的空闲时间。

unit ： 线程池维护线程所允许的空闲时间的单位。

workQueue ： 线程池所使用的缓冲队列，改缓冲队列的长度决定了能够缓冲的最大数量。

拒绝任务：拒绝任务是指当线程池里面的线程数量达到 maximumPoolSize 且 workQueue 队列已满的情况下被尝试添加进来的任务。

handler ： 线程池对拒绝任务的处理策略。在 ThreadPoolExecutor 里面定义了 4 种 handler 策略，分别是

1. CallerRunsPolicy ：这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功。

2. AbortPolicy ：对拒绝任务抛弃处理，并且抛出异常。

3. DiscardPolicy ：对拒绝任务直接无声抛弃，没有异常信息。

4. DiscardOldestPolicy ：对拒绝任务不抛弃，而是抛弃队列里面等待最久的一个线程，然后把拒绝任务加到队列。

 

一个任务通过 execute(Runnable) 方法被添加到线程池，任务就是一个 Runnable 类型的对象，任务的执行方法就是 Runnable 类型对象的 run() 方法。

当一个任务通过 execute(Runnable) 方法欲添加到线程池时，线程池采用的策略如下：

1. 如果此时线程池中的数量小于 corePoolSize ，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

2. 如果此时线程池中的数量等于 corePoolSize ，但是缓冲队列 workQueue 未满，那么任务被放入缓冲队列。

3. 如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量小于 maximumPoolSize ，建新的线程来处理被添加的任务。

4. 如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量等于 maximumPoolSize ，那么通过 handler 所指定的策略来处理此任务。

处理任务的优先级为：

核心线程 corePoolSize 、任务队列 workQueue 、最大线程 maximumPoolSize ，如果三者都满了，使用 handler 处理被拒绝的任务。当线程池中的线程数量大于 corePoolSize 时，如果某线程空闲时间超过 keepAliveTime ，线程将被终止。这样，线程池可以动态的调整池中的线程数。

理解了上面关于 ThreadPoolExecutord 的介绍，应该就基本能了解它的一些使用，不过在 ThreadPoolExocutor 里面有个关键的 Worker 类，所有的线程都要经过 Worker 的包装。这样才能够做到线程可以复用而无需重新创建线程。

同时 Executors 类里面有 newFixedThreadPool(),newCachedThreadPool() 等几个方法，实际上也是间接调用了 ThreadPoolExocutor ，不过是传的不同的构造参数。

下面通过一个例子的执行结果来理解

 

代码：

 

上面代码定义了一个 corePoolSize 为 2 ， maximumPoolSize 为 3 ， workerQuene 容量为 3 的线程池，也就是说在饱和状态下，只能容纳 6 个线程， 3 个是运行状态， 3 个在队列里面。同时代码又往线程池里面添加了 9 个线程，每个线程会运行 2 秒，这样必然会到达饱和状态。而饱和状态就涉及到对拒绝任务的处理策略，本处采用了 ThreadPoolExecutor.DiscardOldestPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

put task@ 7

put task@ 8

put task@ 9

start ..task@ 8

start ..task@ 9

采用 ThreadPoolExecutor.DiscardOldestPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

start ..task@ 6

start ..task@ 4

start ..task@ 5

put task@ 7

start ..task@ 7

put task@ 8

put task@ 9

start ..task@ 8

start ..task@ 9

采用 ThreadPoolExecutor.AbortPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

put task@ 7

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

put task@ 8

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

put task@ 9

java.util.concurrent.RejectedExecutionException

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution( ThreadPoolExecutor.java:1477 )

at java.util.concurrent.ThreadPoolExecutor.reject( ThreadPoolExecutor.java:384 )

at java.util.concurrent.ThreadPoolExecutor.execute( ThreadPoolExecutor.java:867 )

at TestThreadPool.main( TestThreadPool.java:22 )

start ..task@ 4

start ..task@ 5

采用 ThreadPoolExecutor.DiscardPolicy() 的 运行结果如下：

put task@ 1

start ..task@ 1

put task@ 2

start ..task@ 2

put task@ 3

put task@ 4

put task@ 5

start ..task@ 3

put task@ 6

put task@ 7

put task@ 8

put task@ 9

start ..task@ 4

start ..task@ 5

从运行结果可以看出不同的 Handler 策略对拒绝任务的处理方式。

目前还只偏重在使用层面的理解，底层细节的原理还有待日后学习，欢迎交流。

 

 

本文部分内容和例子参考了： http://blog.csdn.net/imicro/archive/2007/08/29/1763955.aspx

 

 

abing37
关注
专栏目录
Java线程池ThreadPoolExecutor原理及使用实例
08-19
Java线程池ThreadPoolExecutor原理及使用实例 Java线程池ThreadPoolExecutor是Java并发编程中的一种基本机制，主要用于管理和执行任务的线程池。下面对其原理和使用实例进行详细介绍。 线程池概述 线程池是一个...
ThreadPoolExecutor
dashalen的博客
08-17 705
public class XmallQueryLogManager implements Runnable { private final static Logger logger = LoggerFactory.getLogger(XmallQueryLogManager.class); private static BlockingQueue<XmallQueryL...
四种线程池拒绝策略
360linker
11-11 702
一、前言 线程池，相信很多人都有用过，没用过相信的也有学习过。但是，线程池的拒绝策略，相信知道的人会少许多。 二、四种线程池拒绝策略 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略： ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛
13、线程池ThreadPoolExecutor实战及其原理分析
最新发布
weixin_43164559的博客
09-25 954
线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如Tomcat。线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。：任务到达时，无需等待线程创建即可立即执行。
ThreadPoolExecutor.CallerRunsPolicy 可伸缩队列
weixin_35757531的博客
02-14 1691
ThreadPoolExecutor.CallerRunsPolicy 是一种可伸缩队列策略。这种策略是当线程池中的线程数达到最大值，并且已提交的任务数大于线程池中的线程数时，任务将在调用者线程中执行，而不是在线程池中的线程中执行。这个策略可以控制任务的执行速度，防止线程池中的任务过多导致的资源耗尽。 ...
线程池有哪 4 种拒绝策略？
m0_45223880的博客
07-15 6874
第一种拒绝策略是 AbortPolicy，这种拒绝策略在拒绝任务时，会直接抛出一个类型为 RejectedExecutionException 的 RuntimeException，让你感知到任务被拒绝了，于是你便可以根据业务逻辑选择重试或者放弃提交等策略。 第二种拒绝策略是 DiscardPolicy，这种拒绝策略正如它的名字所描述的一样，当新任务被提交后直接被丢弃掉，也不会给你任何的通知，相对而言存在一定的风险，因为我们提交的时候根本不知道这个任务会被丢弃，可能造成数据丢失。 第三种拒绝策略是 Dis.
Java ThreadPoolExecutor的拒绝策略CallerRunsPolicy的一个潜在的大坑
明明如月的技术博客
05-07 2万+
一、背景 前面一篇文章转载了ThreadPoolExecutor的几种拒绝策略：https://blog.csdn.net/w605283073/article/details/89930154，讲得很不错。 但是网上介绍使用拒绝策略遇到的大坑的文章不多。 本文介绍其中一个真是故障的场景。 二、问题描述 ThreadPoolExecutor的拒绝策略常用的是DiscardPolicy...
java线程池ThreadPoolExecutor类使用详解.docx
06-21
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了...
12、线程池ThreadPoolExecutor实战及其原理分析(下)
03-07
线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor...
Java线程池与ThreadPoolExecutor.pdf
07-01
Java线程池是Java并发编程中...总结来说，理解并正确使用Java线程池和ThreadPoolExecutor对于优化Java应用程序的并发性能至关重要。通过调整线程池的参数，可以平衡资源利用率和系统响应时间，从而提高整体的系统效率。
Java ThreadPoolExecutor 线程池的使用介绍
08-26
提供工厂方法来创建不同类型的线程池，这篇文章主要介绍了Java ThreadPoolExecutor 线程池的使用介绍，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来...
线程池ThreadPoolExecutor
12-21
线程池是Java中一种高效的线程管理工具，它的出现是为了优化线程的创建和销毁过程，因为这两个操作在实际应用中可能会消耗大量资源。线程池通过预先创建一定数量的线程，使得任务能够迅速分配到线程上执行，从而提高...
11、线程池ThreadPoolExecutor实战及其原理分析(上)
03-07
线程池ThreadPoolExecutor实战及其原理分析(上)
线程池ThreadPoolExecutor原理源码分析.md
01-22
### 线程池 `ThreadPoolExecutor` 原理源码分析 #### 一、概述 线程池作为 Java 并发编程中的重要组件，在实际应用中被广泛使用。其核心类 `ThreadPoolExecutor` 实现了对线程的管理、调度等功能。本文将围绕 `...
线程池ThreadPoolExecutor使用简介与方法实例
08-26
线程池ThreadPoolExecutor是Java并发编程中一个非常重要的概念，它允许开发者将任务提交给线程池，并由线程池来管理这些任务的执行。今天，我们将对线程池ThreadPoolExecutor进行详细的介绍，并提供一些实际的使用...
java线程池封装j
08-13
Java线程池是一种高效管理线程的技术，它允许开发者预定义一组线程，根据任务的需要灵活调度，而不是每次需要执行任务时都创建新的线程。这种设计模式大大提高了系统的性能，减少了系统资源的消耗，特别是在高并发...
线程池——ThreadPoolExecutor
qq_18684463的博客
04-17 3222
线程池（Thread Pool）：把一个或多个线程通过统一的方式进行调度和重复使用的技术，避免了因为线程过多而带来使用上的开销。为什么要使用线程池？可重复使用已有线程，避免对象创建、消亡和过度切换的性能开销。避免创建大量同类线程所导致的资源过度竞争和内存溢出的问题。支持更多功能，比如延迟任务线程池（newScheduledThreadPool）和缓存线程池（newCachedThreadPool）等。
不能错过的java 多线程总结终结版
不会吉他的肌肉男不是好的挨踢男的专栏
04-28 324
作为一个合格的java程序员，说到多线程我们应该很快的想到 线程池如何让创建？线程池的核心属性有哪些？线程池的优势又有哪些？使用线程池不当又会出现什么样的问题？ 一 、我们为什么需要使用线程池？ 总体来说，线程池有如下的优势： （1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 （2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 （3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分.
ThreadPoolExecutor里面4种拒绝策略（详细）
热门推荐
long_here的专栏
05-23 9万+
ThreadPoolExecutor类实现了ExecutorService接口和Executor接口，可以设置线程池corePoolSize，最大线程池大小，AliveTime，拒绝策略等。常用构造方法： ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, B
java线程池ThreadPoolExecutor
08-03
Java线程池ThreadPoolExecutor是Java中的核心线程池实现类。它是通过使用ThreadPoolExecutor来创建和管理线程池的。在Spring框架中，使用ThreadPoolTaskExecutor来管理线程池，它是对ThreadPoolExecutor进行封装，使...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值