Java ThreadPoolExecutor - 版本历史

Riguz：Riguz移动页面Blog:理解Java并发(2)：ThreadPoolExecutor解析至Java ThreadPoolExecutor，不留重定向

2023-12-19T06:48:52Z

Riguz移动页面Blog:理解Java并发(2)：ThreadPoolExecutor解析至Java ThreadPoolExecutor，不留重定向

←上一版本	2023年12月19日 (二) 06:48的版本
（没有差异）

Riguz：/* workQueue */

2021-05-13T07:38:45Z

workQueue

←上一版本		2021年5月13日 (四) 07:38的版本
第102行：		第102行：
	* 使用无界的队列例如<syntaxhighlight lang="java" inline>LinkedBlockingQueue</syntaxhighlight>，那么一旦线程超过<span class="article-label">corePoolSize</span>的时候新线程都会被加入到队列中，也就是说<span class="article-label">maximumPoolSize</span>根本不会生效了。		* 使用无界的队列例如<syntaxhighlight lang="java" inline>LinkedBlockingQueue</syntaxhighlight>，那么一旦线程超过<span class="article-label">corePoolSize</span>的时候新线程都会被加入到队列中，也就是说<span class="article-label">maximumPoolSize</span>根本不会生效了。
	* 使用有界队列例如<syntaxhighlight lang="java" inline>ArrayBlockingQueue</syntaxhighlight>，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。		* 使用有界队列例如<syntaxhighlight lang="java" inline>ArrayBlockingQueue</syntaxhighlight>，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。
			=== 拒绝策略===
			当线程池满了无法继续接受新的task的时候，会使用拒绝策略来进行处理。支持的策略有：
			;AbortPolicy:抛出<span class="article-label">RejectedExecutionException</span>异常
			;DiscardPolicy:直接忽略掉
			;DiscardOldestPolicy:将队列中最早的task丢弃掉然后重新尝试执行
			;CallerRunsPolicy: 拒绝后直接在主线程里面去执行task

	References:		References:

Riguz：/* workQueue */

2021-04-28T13:19:05Z

workQueue

←上一版本		2021年4月28日 (三) 13:19的版本
第109行：		第109行：
	* [http://baddotrobot.com/blog/2009/02/26/less-is-more/ Less is More]		* [http://baddotrobot.com/blog/2009/02/26/less-is-more/ Less is More]
	* [https://stackoverflow.com/questions/5483047/why-is-creating-a-thread-said-to-be-expensive Why is creating a Thread said to be expensive?]		* [https://stackoverflow.com/questions/5483047/why-is-creating-a-thread-said-to-be-expensive Why is creating a Thread said to be expensive?]

			[[Category:Concurrency]]

Riguz：/* workQueue */

2021-04-28T13:13:14Z

workQueue

←上一版本		2021年4月28日 (三) 13:13的版本
第99行：		第99行：
	对于队列的选择也可以使用不同的策略：		对于队列的选择也可以使用不同的策略：

	* 使用<syntaxhighlight lang="java" inline>SynchronousQueue</syntaxhighlight>可以直接将任务从队列转手到线程池，这个参数要配合将maximumPoolSize设置为无限大来配合使用。因为这个朝这个队列中插入一条数据将会阻塞一直到它被消费，也就是说读写操作要配套，实际上就是进行了一个数据交换，根本没有在队列中实际存储任务。如果<span class="article-label">maximumPoolSize</span>太小可能会导致任务被拒绝。		* 使用<syntaxhighlight lang="java" inline>SynchronousQueue</syntaxhighlight>可以直接将任务从队列转手到线程池，这个参数要配合将<span class="article-label">maximumPoolSize</span>设置为无限大来配合使用。因为这个朝这个队列中插入一条数据将会阻塞一直到它被消费，也就是说读写操作要配套，实际上就是进行了一个数据交换，根本没有在队列中实际存储任务。如果<span class="article-label">maximumPoolSize</span>太小可能会导致任务被拒绝。
	* 使用无界的队列例如<syntaxhighlight lang="java" inline>LinkedBlockingQueue</syntaxhighlight>，那么一旦线程超过<span class="article-label">corePoolSize</span>的时候新线程都会被加入到队列中，也就是说<span class="article-label">maximumPoolSize</span>根本不会生效了。		* 使用无界的队列例如<syntaxhighlight lang="java" inline>LinkedBlockingQueue</syntaxhighlight>，那么一旦线程超过<span class="article-label">corePoolSize</span>的时候新线程都会被加入到队列中，也就是说<span class="article-label">maximumPoolSize</span>根本不会生效了。
	* 使用有界队列例如<syntaxhighlight lang="java" inline>ArrayBlockingQueue</syntaxhighlight>，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。		* 使用有界队列例如<syntaxhighlight lang="java" inline>ArrayBlockingQueue</syntaxhighlight>，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。

Riguz：/* ThreadPoolExecutor */

2021-04-28T13:12:48Z

ThreadPoolExecutor

←上一版本		2021年4月28日 (三) 13:12的版本
第92行：		第92行：
	工作队列用来持有提交的任务。规则如下：		工作队列用来持有提交的任务。规则如下：

	* ~~如果当前池中的线程少于corePoolSize，则创建新的线程~~		* 如果当前池中的线程少于<span class="article-label">corePoolSize</span>，则创建新的线程
	* ~~如果大于corePoolSize，则倾向于将任务加入到workQueue中~~		* 如果大于<span class="article-label">corePoolSize</span>，则倾向于将任务加入到<span class="article-label">workQueue</span>中
	* ~~如果无法将任务加入到队列中，则会创建新的线程，直到池中的线程数达到maximumPoolSize~~		* 如果无法将任务加入到队列中，则会创建新的线程，直到池中的线程数达到<span class="article-label">maximumPoolSize</span>
	* ~~如果超过maximumPoolSize，那么将会拒绝提交的任务~~		* 如果超过<span class="article-label">maximumPoolSize</span>，那么将会拒绝提交的任务

	对于队列的选择也可以使用不同的策略：		对于队列的选择也可以使用不同的策略：

	* 使用`SynchronousQueue`可以直接将任务从队列转手到线程池，这个参数要配合将maximumPoolSize设置为无限大来配合使用。因为这个朝这个队列中插入一条数据将会阻塞一直到它被消费，也就是说读写操作要配套，实际上就是进行了一个数据交换，根本没有在队列中实际存储任务。如果maximumPoolSize太小可能会导致任务被拒绝。		* 使用<syntaxhighlight lang="java" inline>SynchronousQueue</syntaxhighlight>可以直接将任务从队列转手到线程池，这个参数要配合将maximumPoolSize设置为无限大来配合使用。因为这个朝这个队列中插入一条数据将会阻塞一直到它被消费，也就是说读写操作要配套，实际上就是进行了一个数据交换，根本没有在队列中实际存储任务。如果<span class="article-label">maximumPoolSize</span>太小可能会导致任务被拒绝。
	* 使用无界的队列例如''LinkedBlockingQueue~~''，那么一旦线程超过corePoolSize的时候新线程都会被加入到队列中，也就是说maximumPoolSize根本不会生效了。~~		* 使用无界的队列例如<syntaxhighlight lang="java" inline>LinkedBlockingQueue</syntaxhighlight>，那么一旦线程超过<span class="article-label">corePoolSize</span>的时候新线程都会被加入到队列中，也就是说<span class="article-label">maximumPoolSize</span>根本不会生效了。
	* 使用有界队列例如''ArrayBlockingQueue''，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。		* 使用有界队列例如<syntaxhighlight lang="java" inline>ArrayBlockingQueue</syntaxhighlight>，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。

	References:		References:

Riguz：/* 线程池 */

2021-04-28T12:53:20Z

线程池

←上一版本		2021年4月28日 (三) 12:53的版本
第42行：		第42行：
	在Java中线程的启动和停止是有开销的。这个开销主要包括：		在Java中线程的启动和停止是有开销的。这个开销主要包括：

	* 为线程开辟栈空间（例如OpenJDK6在Linux上会使用''pthread_create''来创建线程，内部使用''mmap''分配内存)		* 为线程开辟栈空间（例如OpenJDK6在Linux上会使用<span class="article-label">pthread_create</span>来创建线程，内部使用<span class="article-label">mmap</span>分配内存)
	* 通过操作系统的调用来创建和注册本地线程		* 通过操作系统的调用来创建和注册本地线程
	* 保存线程的相关信息（JVM/native thread descriptors)到JVM中		* 保存线程的相关信息（JVM/native thread descriptors)到JVM中
第68行：		第68行：
	线程池会根据这两个参数去管理池中的线程。当一个新的任务提交的时候，会遵循如下的规则：		线程池会根据这两个参数去管理池中的线程。当一个新的任务提交的时候，会遵循如下的规则：

	* ~~如果池中线程数小于corePoolSize，哪怕有空闲的线程也会创建一个新的线程来~~		* 如果池中线程数小于<span class="article-label">corePoolSize</span>，哪怕有空闲的线程也会创建一个新的线程来
	* ~~当吃中线程数超过corePoolSize但是小于MaximumPoolSize的时候，只有当workQueue满的时候才会创建新的线程~~		* 当吃中线程数超过<span class="article-label">corePoolSize</span>但是小于<span class="article-label">MaximumPoolSize</span>的时候，只有当<span class="article-label">workQueue</span>满的时候才会创建新的线程

	~~所以当corePoolSize和MaximumPoolSize一样的时候，实际上就是一个固定大小的线程池，相当于使用''~~Executors.newFixedThreadPool'':		所以当<span class="article-label">corePoolSize</span>和<span class="article-label">MaximumPoolSize</span>一样的时候，实际上就是一个固定大小的线程池，相当于使用<syntaxhighlight lang="java" inline>Executors.newFixedThreadPool</syntaxhighlight>:

	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
第81行：		第81行：
	</syntaxhighlight>		</syntaxhighlight>

	池中的线程默认只要当提交了新任务的时候才会创建，如果希望提前创建线程可以使用''prestartCoreThread''或者''prestartAllCoreThreads''。		池中的线程默认只要当提交了新任务的时候才会创建，如果希望提前创建线程可以使用<syntaxhighlight lang="java" inline>prestartCoreThread()</syntaxhighlight>或者<syntaxhighlight lang="java" inline>prestartAllCoreThreads()</syntaxhighlight>。

	=== Keep-alive 时间===		=== Keep-alive 时间===

	当池中的线程数多余corePoolSize的时候，超出部分的线程会在空闲一段时间之后被终止掉，这个时间就是keepAliveTime。如果设置为0那么一旦超出部分运行结束之后就会被终止掉，反之如果设置为''Long.MAX_VALUE''那么空闲线程就会一直存活。		当池中的线程数多余<span class="article-label">corePoolSize</span>的时候，超出部分的线程会在空闲一段时间之后被终止掉，这个时间就是<span class="article-label">keepAliveTime</span>。如果设置为0那么一旦超出部分运行结束之后就会被终止掉，反之如果设置为<syntaxhighlight lang="java" inline>Long.MAX_VALUE</syntaxhighlight>那么空闲线程就会一直存活。

	~~默认情况下，只有超出corePoolSize的线程才会受到这个存活时间的影响，如果希望对于核心线程也能超时终止，那么可以使用''~~allowCoreThreadTimeOut''来控制。		默认情况下，只有超出<span class="article-label">corePoolSize</span>的线程才会受到这个存活时间的影响，如果希望对于核心线程也能超时终止，那么可以使用<syntaxhighlight lang="java" inline>allowCoreThreadTimeOut</syntaxhighlight>来控制。

	=== workQueue===		=== workQueue===

Riguz：/* JVM限制 */

2021-04-28T12:42:28Z

JVM限制

←上一版本		2021年4月28日 (三) 12:42的版本
第22行：		第22行：
	== JVM限制==		== JVM限制==

	JVM本身貌似没有对线程数进行限制，但同样不能无限制的创建线程否则会出现''java.lang.OutOfMemoryError: unable to create new native thread''。在JVM中有以下的一些参数可能会影响能创建的线程数：		JVM本身貌似没有对线程数进行限制，但同样不能无限制的创建线程否则会出现<span class="article-label">java.lang.OutOfMemoryError: unable to create new native thread</span>。在JVM中有以下的一些参数可能会影响能创建的线程数：

	* -Xms 设置堆的最小值		* <span class="article-label">-Xms</span> 设置堆的最小值
	* -Xmx 设置堆的最大值		* <span class="article-label">-Xmx</span> 设置堆的最大值
	* -Xss 设置每个线程的stack大小		* <span class="article-label">-Xss</span> 设置每个线程的stack大小

	因为一个机器上的内存是一定的，所以如果''-Xss''设置的越大，单个线程所占用的栈空间越大，那么能创建的线程数就越少。一个比较有趣的事实是，能创建的最大线程数是跟''-Xmx''的值负相关的，即你设置的堆越大，反而能创建的最大线程数越少！这是别人的测试结果：		因为一个机器上的内存是一定的，所以如果<span class="article-label">-Xss</span>设置的越大，单个线程所占用的栈空间越大，那么能创建的线程数就越少。一个比较有趣的事实是，能创建的最大线程数是跟<span class="article-label">-Xmx</span>的值负相关的，即你设置的堆越大，反而能创建的最大线程数越少！这是别人的测试结果：

	<pre>		<pre>

Riguz：/* CorePoolSize / MaximumPoolSize */

2021-04-28T07:01:10Z

CorePoolSize / MaximumPoolSize

←上一版本		2021年4月28日 (三) 07:01的版本
第71行：		第71行：
	* 当吃中线程数超过corePoolSize但是小于MaximumPoolSize的时候，只有当workQueue满的时候才会创建新的线程		* 当吃中线程数超过corePoolSize但是小于MaximumPoolSize的时候，只有当workQueue满的时候才会创建新的线程

	所以当corePoolSize和MaximumPoolSize一样的时候，实际上就是一个固定大小的线程池，相当于使用`Executors.newFixedThreadPool`:		所以当corePoolSize和MaximumPoolSize一样的时候，实际上就是一个固定大小的线程池，相当于使用''Executors.newFixedThreadPool'':

	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
第81行：		第81行：
	</syntaxhighlight>		</syntaxhighlight>

	池中的线程默认只要当提交了新任务的时候才会创建，如果希望提前创建线程可以使用`prestartCoreThread`或者`prestartAllCoreThreads`。		池中的线程默认只要当提交了新任务的时候才会创建，如果希望提前创建线程可以使用''prestartCoreThread''或者''prestartAllCoreThreads''。

	=== Keep-alive 时间===		=== Keep-alive 时间===

Riguz：/* 线程池 */

2021-04-28T04:01:50Z

线程池

←上一版本		2021年4月28日 (三) 04:01的版本
第42行：		第42行：
	在Java中线程的启动和停止是有开销的。这个开销主要包括：		在Java中线程的启动和停止是有开销的。这个开销主要包括：

	* 为线程开辟栈空间（例如OpenJDK6在Linux上会使用`pthread_create`来创建线程，内部使用`mmap`分配内存)		* 为线程开辟栈空间（例如OpenJDK6在Linux上会使用''pthread_create''来创建线程，内部使用''mmap''分配内存)
	* 通过操作系统的调用来创建和注册本地线程		* 通过操作系统的调用来创建和注册本地线程
	* 保存线程的相关信息（JVM/native thread descriptors)到JVM中		* 保存线程的相关信息（JVM/native thread descriptors)到JVM中
第85行：		第85行：
	=== Keep-alive 时间===		=== Keep-alive 时间===

	当池中的线程数多余corePoolSize的时候，超出部分的线程会在空闲一段时间之后被终止掉，这个时间就是keepAliveTime。如果设置为0那么一旦超出部分运行结束之后就会被终止掉，反之如果设置为`Long.MAX_VALUE`那么空闲线程就会一直存活。		当池中的线程数多余corePoolSize的时候，超出部分的线程会在空闲一段时间之后被终止掉，这个时间就是keepAliveTime。如果设置为0那么一旦超出部分运行结束之后就会被终止掉，反之如果设置为''Long.MAX_VALUE''那么空闲线程就会一直存活。

	默认情况下，只有超出corePoolSize的线程才会受到这个存活时间的影响，如果希望对于核心线程也能超时终止，那么可以使用`allowCoreThreadTimeOut`来控制。		默认情况下，只有超出corePoolSize的线程才会受到这个存活时间的影响，如果希望对于核心线程也能超时终止，那么可以使用''allowCoreThreadTimeOut''来控制。

	=== workQueue===		=== workQueue===
第100行：		第100行：

	* 使用`SynchronousQueue`可以直接将任务从队列转手到线程池，这个参数要配合将maximumPoolSize设置为无限大来配合使用。因为这个朝这个队列中插入一条数据将会阻塞一直到它被消费，也就是说读写操作要配套，实际上就是进行了一个数据交换，根本没有在队列中实际存储任务。如果maximumPoolSize太小可能会导致任务被拒绝。		* 使用`SynchronousQueue`可以直接将任务从队列转手到线程池，这个参数要配合将maximumPoolSize设置为无限大来配合使用。因为这个朝这个队列中插入一条数据将会阻塞一直到它被消费，也就是说读写操作要配套，实际上就是进行了一个数据交换，根本没有在队列中实际存储任务。如果maximumPoolSize太小可能会导致任务被拒绝。
	* 使用无界的队列例如`LinkedBlockingQueue`，那么一旦线程超过corePoolSize的时候新线程都会被加入到队列中，也就是说maximumPoolSize根本不会生效了。		* 使用无界的队列例如''LinkedBlockingQueue''，那么一旦线程超过corePoolSize的时候新线程都会被加入到队列中，也就是说maximumPoolSize根本不会生效了。
	* 使用有界队列例如`ArrayBlockingQueue`，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。		* 使用有界队列例如''ArrayBlockingQueue''，超过队列数的新任务将创建新的线程。那么这时候队列大小和线程数上限需要权衡配合。

	References:		References:

Riguz：/* JVM限制 */

2021-04-28T03:59:33Z

JVM限制

←上一版本		2021年4月28日 (三) 03:59的版本
第22行：		第22行：
	== JVM限制==		== JVM限制==

	JVM本身貌似没有对线程数进行限制，但同样不能无限制的创建线程否则会出现`java.lang.OutOfMemoryError: unable to create new native thread`。在JVM中有以下的一些参数可能会影响能创建的线程数：		JVM本身貌似没有对线程数进行限制，但同样不能无限制的创建线程否则会出现''java.lang.OutOfMemoryError: unable to create new native thread''。在JVM中有以下的一些参数可能会影响能创建的线程数：

	* -Xms 设置堆的最小值		* -Xms 设置堆的最小值
第28行：		第28行：
	* -Xss 设置每个线程的stack大小		* -Xss 设置每个线程的stack大小

	因为一个机器上的内存是一定的，所以如果`-Xss`设置的越大，单个线程所占用的栈空间越大，那么能创建的线程数就越少。一个比较有趣的事实是，能创建的最大线程数是跟`-Xmx`的值负相关的，即你设置的堆越大，反而能创建的最大线程数越少！这是别人的测试结果：		因为一个机器上的内存是一定的，所以如果''-Xss''设置的越大，单个线程所占用的栈空间越大，那么能创建的线程数就越少。一个比较有趣的事实是，能创建的最大线程数是跟''-Xmx''的值负相关的，即你设置的堆越大，反而能创建的最大线程数越少！这是别人的测试结果：

	<pre>		<pre>
第109行：		第109行：
	* [http://baddotrobot.com/blog/2009/02/26/less-is-more/ Less is More]		* [http://baddotrobot.com/blog/2009/02/26/less-is-more/ Less is More]
	* [https://stackoverflow.com/questions/5483047/why-is-creating-a-thread-said-to-be-expensive Why is creating a Thread said to be expensive?]		* [https://stackoverflow.com/questions/5483047/why-is-creating-a-thread-said-to-be-expensive Why is creating a Thread said to be expensive?]

Java ThreadPoolExecutor - 版本历史

Riguz：​Riguz移动页面Blog:理解Java并发(2)：ThreadPoolExecutor解析至Java ThreadPoolExecutor，不留重定向

Riguz：​/* workQueue */

Riguz：​/* workQueue */

Riguz：​/* workQueue */

Riguz：​/* ThreadPoolExecutor */

Riguz：​/* 线程池 */

Riguz：​/* JVM限制 */

Riguz：​/* CorePoolSize / MaximumPoolSize */

Riguz：​/* 线程池 */

Riguz：​/* JVM限制 */

Riguz：Riguz移动页面Blog:理解Java并发(2)：ThreadPoolExecutor解析至Java ThreadPoolExecutor，不留重定向

Riguz：/* workQueue */

Riguz：/* workQueue */

Riguz：/* workQueue */

Riguz：/* ThreadPoolExecutor */

Riguz：/* 线程池 */

Riguz：/* JVM限制 */

Riguz：/* CorePoolSize / MaximumPoolSize */

Riguz：/* 线程池 */

Riguz：/* JVM限制 */