ThreadPoolExecutor简介

长平狐 发布于 2012/11/28 15:41
阅读 498
收藏 0
ThreadPoolExecutor
一、 简介


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

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)


corePoolSize : 线程池维护线程的最少数量
maximumPoolSize :线程池维护线程的最大数量
keepAliveTime : 线程池维护线程所允许的空闲时间
unit : 线程池维护线程所允许的空闲时间的单位
workQueue : 线程池所使用的缓冲队列
handler : 线程池对拒绝任务的处理策略

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

当一个任务通过execute(Runnable) 方法欲添加到线程池时:

l 如果此时线程池中的数量小于corePoolSize ,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
l 如果此时线程池中的数量等于 corePoolSize ,但是缓冲队列 workQueue 未满,那么任务被放入缓冲队列。
l 如果此时线程池中的数量大于corePoolSize ,缓冲队列workQueue 满,并且线程池中的数量小于maximumPoolSize ,建新的线程来处理被添加的任务。
l 如果此时线程池中的数量大于corePoolSize ,缓冲队列workQueue 满,并且线程池中的数量等于maximumPoolSize ,那么通过 handler 所指定的策略来处理此任务。也就是:处理任务的优先级为:核心线程corePoolSize 、任务队列workQueue 、最大线程maximumPoolSize ,如果三者都满了,使用handler 处理被拒绝的任务。
l 当线程池中的线程数量大于 corePoolSize 时,如果某线程空闲时间超过keepAliveTime ,线程将被终止。这样,线程池可以动态的调整池中的线程数。

unit 可选的参数为java.util.concurrent.TimeUnit 中的几个静态属性:
NANOSECONDS 、
MICROSECONDS 、
MILLISECONDS 、
SECONDS 。

workQueue 常用的是:java.util.concurrent.ArrayBlockingQueue

handler 有四个选择:
ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException 异常

ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务,他会自动重复调用execute() 方法

ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务

ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务

二、 相关参考

public class ThreadPoolExecutor
   
   
extends AbstractExecutorService
 

一个 ExecutorService,它使用可能的几个池线程之一执行每个提交的任务,通常使用Executors 工厂方法配置。

线程池可以解决两个不同问题:由于减少了每个任务调用的开销,它们通常可以在执行大量异步任务时提供增强的性能,并且还可以提供绑定和管理资源(包括执行任务集时使用的线程)的方法。每个ThreadPoolExecutor 还维护着一些基本的统计数据,如完成的任务数。

为了便于跨大量上下文使用,此类提供了很多可调整的参数和扩展钩子 (hook)。但是,强烈建议程序员使用较为方便的 Executors 工厂方法 Executors.newCachedThreadPool()(无界线程池,可以进行自动线程回收)、Executors.newFixedThreadPool(int)(固定大小线程池)和Executors.newSingleThreadExecutor()(单个后台线程),它们均为大多数使用场景预定义了设置。否则,在手动配置和调整此类时,使用以下指导:

核心和最大池大小
ThreadPoolExecutor 将根据 corePoolSize(参见 getCorePoolSize())和 maximumPoolSize(参见 getMaximumPoolSize())设置的边界自动调整池大小。当新任务在方法 execute(java.lang.Runnable) 中提交时,如果运行的线程少于 corePoolSize,则创建新线程来处理请求,即使其他辅助线程是空闲的。如果运行的线程多于 corePoolSize 而少于 maximumPoolSize,则仅当队列满时才创建新线程。如果设置的 corePoolSize 和 maximumPoolSize 相同,则创建了固定大小的线程池。如果将 maximumPoolSize 设置为基本的无界值(如 Integer.MAX_VALUE),则允许池适应任意数量的并发任务。在大多数情况下,核心和最大池大小仅基于构造来设置,不过也可以使用 setCorePoolSize(int)setMaximumPoolSize(int) 进行动态更改。
按需构造
默认情况下,即使核心线程最初只是在新任务到达时才创建和启动的,也可以使用方法 prestartCoreThread()prestartAllCoreThreads() 对其进行动态重写。如果构造带有非空队列的池,则可能希望预先启动线程。
创建新线程
使用 ThreadFactory 创建新线程。如果没有另外说明,则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程,并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。通过提供不同的 ThreadFactory,可以改变线程的名称、线程组、优先级、守护进程状态,等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程,则执行程序将继续运行,但不能执行任何任务。
保持活动时间
如果池中当前有多于 corePoolSize 的线程,则这些多出的线程在空闲时间超过 keepAliveTime 时将会终止(参见 getKeepAliveTime(java.util.concurrent.TimeUnit))。这提供了当池处于非活动状态时减少资源消耗的方法。如果池后来变得更为活动,则可以创建新的线程。也可以使用方法 setKeepAliveTime(long, java.util.concurrent.TimeUnit) 动态地更改此参数。使用 Long.MAX_VALUE TimeUnit.NANOSECONDS 的值在关闭前有效地从以前的终止状态禁用空闲线程。默认情况下,保持活动策略只在有多于 corePoolSizeThreads 的线程时应用。但是只要 keepAliveTime 值非 0, allowCoreThreadTimeOut(boolean) 方法也可将此超时策略应用于核心线程。
排队
所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互:
  • 如果运行的线程少于 corePoolSize,则 Executor 始终首选添加新的线程,而不进行排队。
  • 如果运行的线程等于或多于 corePoolSize,则 Executor 始终首选将请求加入队列,而不添加新的线程。
  • 如果无法将请求加入队列,则创建新的线程,除非创建此线程超出 maximumPoolSize,在这种情况下,任务将被拒绝。
排队有三种通用策略:
  1. 直接提交。工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们。在此,如果不存在可用于立即运行任务的线程,则试图把任务加入队列将失败,因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
  2. 无界队列。使用无界队列(例如,不具有预定义容量的 LinkedBlockingQueue)将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样,创建的线程就不会超过 corePoolSize。(因此,maximumPoolSize 的值也就无效了。)当每个任务完全独立于其他任务,即任务执行互不影响时,适合于使用无界队列;例如,在 Web 页服务器中。这种排队可用于处理瞬态突发请求,当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
  3. 有界队列。当使用有限的 maximumPoolSizes 时,有界队列(如 ArrayBlockingQueue)有助于防止资源耗尽,但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷:使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销,但是可能导致人工降低吞吐量。如果任务频繁阻塞(例如,如果它们是 I/O 边界),则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小,CPU 使用率较高,但是可能遇到不可接受的调度开销,这样也会降低吞吐量。
被拒绝的任务
当 Executor 已经关闭,并且 Executor 将有限边界用于最大线程和工作队列容量,且已经饱和时,在方法 execute(java.lang.Runnable) 中提交的新任务将被 拒绝。在以上两种情况下, execute 方法都将调用其 RejectedExecutionHandlerRejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略:
  1. 在默认的 ThreadPoolExecutor.AbortPolicy 中,处理程序遭到拒绝将抛出运行时RejectedExecutionException
  2. ThreadPoolExecutor.CallerRunsPolicy 中,线程调用运行该任务的execute 本身。此策略提供简单的反馈控制机制,能够减缓新任务的提交速度。
  3. ThreadPoolExecutor.DiscardPolicy 中,不能执行的任务将被删除。
  4. ThreadPoolExecutor.DiscardOldestPolicy 中,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,然后重试执行程序(如果再次失败,则重复此过程)。
定义和使用其他种类的 RejectedExecutionHandler 类也是可能的,但这样做需要非常小心,尤其是当策略仅用于特定容量或排队策略时。
钩子 (hook) 方法
此类提供 protected 可重写的 beforeExecute(java.lang.Thread, java.lang.Runnable)afterExecute(java.lang.Runnable, java.lang.Throwable) 方法,这两种方法分别在执行每个任务之前和之后调用。它们可用于操纵执行环境;例如,重新初始化 ThreadLocal、搜集统计信息或添加日志条目。此外,还可以重写方法 terminated() 来执行 Executor 完全终止后需要完成的所有特殊处理。

如果钩子 (hook) 或回调方法抛出异常,则内部辅助线程将依次失败并突然终止。

队列维护
方法 getQueue() 允许出于监控和调试目的而访问工作队列。强烈反对出于其他任何目的而使用此方法。 remove(java.lang.Runnable)purge() 这两种方法可用于在取消大量已排队任务时帮助进行存储回收。
终止
程序 AND 不再引用的池没有剩余线程会自动 shutdown。如果希望确保回收取消引用的池(即使用户忘记调用 shutdown()),则必须安排未使用的线程最终终止:设置适当保持活动时间,使用 0 核心线程的下边界和/或设置 allowCoreThreadTimeOut(boolean)

扩展示例。此类的大多数扩展可以重写一个或多个受保护的钩子 (hook) 方法。例如,下面是一个添加了简单的暂停/恢复功能的子类:

 class PausableThreadPoolExecutor extends ThreadPoolExecutor {
   private boolean isPaused;
   private ReentrantLock pauseLock = new ReentrantLock();
   private Condition unpaused = pauseLock.newCondition();

   public PausableThreadPoolExecutor(...) { super(...); }
 
   protected void beforeExecute(Thread t, Runnable r) {
     super.beforeExecute(t, r);
     pauseLock.lock();
     try {
       while (isPaused) unpaused.await();
     } catch(InterruptedException ie) {
       t.interrupt();
     } finally {
       pauseLock.unlock();
     }
   }
 
   public void pause() {
     pauseLock.lock();
     try {
       isPaused = true;
     } finally {
       pauseLock.unlock();
     }
   }
 
   public void resume() {
     pauseLock.lock();
     try {
       isPaused = false;
       unpaused.signalAll();
     } finally {
       pauseLock.unlock();
     }
   }
 }
 


一、 例子

创建 TestThreadPool 类:

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class TestThreadPool { 

private static int produceTaskSleepTime = 2 ; 

private static int produceTaskMaxNumber = 10 ; 

public static void main(String[] args) { 

// 构造一个线程池 
ThreadPoolExecutor threadPool = new ThreadPoolExecutor( 2 , 4 , 3 , 
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>( 3 ), 
new ThreadPoolExecutor.DiscardOldestPolicy()); 

for ( int i = 1 ; i <= produceTaskMaxNumber; i++) { 
try { 
String task = "task@ " + i; 
System.out.println("创建任务并提交到线程池中:" + task); 
threadPool.execute(new ThreadPoolTask(task)); 

Thread.sleep(produceTaskSleepTime); 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
} 
} 


创建 ThreadPoolTask 类:

import java.io.Serializable; 
public class ThreadPoolTask implements Runnable, Serializable { 
private Object attachData; 
ThreadPoolTask(Object tasks) { 
this.attachData = tasks; 
} 
public void run() { 

System.out.println("开始执行任务:" + attachData); 

attachData = null; 
} 
public Object getTask() { 
return this.attachData; 
} 
} 



执行结果:
创建任务并提交到线程池中: task@ 1
开始执行任务: task@ 1
创建任务并提交到线程池中: task@ 2
开始执行任务: task@ 2
创建任务并提交到线程池中: task@ 3
创建任务并提交到线程池中: task@ 4
开始执行任务: task@ 3
创建任务并提交到线程池中: task@ 5
开始执行任务: task@ 4
创建任务并提交到线程池中: task@ 6
创建任务并提交到线程池中: task@ 7
创建任务并提交到线程池中: task@ 8
开始执行任务: task@ 5
开始执行任务: task@ 6
创建任务并提交到线程池中: task@ 9
开始执行任务: task@ 7
创建任务并提交到线程池中: task@ 10
开始执行任务: task@ 8
开始执行任务: task@ 9
开始执行任务: task@ 10
ThreadPoolExecutor配置
< type="text/javascript"> < type="text/javascript">
一、ThreadPoolExcutor为一些Executor提供了基本的实现,这些Executor是由Executors中的工厂 newCahceThreadPool、newFixedThreadPool和newScheduledThreadExecutor返回的。 ThreadPoolExecutor是一个灵活的健壮的池实现,允许各种各样的用户定制。
二、线程的创建与销毁
1、核心池大小、最大池大小和存活时间共同管理着线程的创建与销毁。
2、核心池的大小是目标的大小;线程池的实现试图维护池的大小;即使没有任务执行,池的大小也等于核心池的大小,并直到工作队列充满前,池都不会创建更多的线程。如果当前池的大小超过了核心池的大小,线程池就会终止它。
3、最大池的大小是可同时活动的线程数的上限。
4、如果一个线程已经闲置的时间超过了存活时间,它将成为一个被回收的候选者。
5、newFixedThreadPool工厂为请求的池设置了核心池的大小和最大池的大小,而且池永远不会超时
6、newCacheThreadPool工厂将最大池的大小设置为Integer.MAX_VALUE,核心池的大小设置为0,超时设置为一分钟。这样创建了无限扩大的线程池,会在需求量减少的情况下减少线程数量。
三、管理
1、 ThreadPoolExecutor允许你提供一个BlockingQueue来持有等待执行的任务。任务排队有3种基本方法:无限队列、有限队列和同步移交。
2、 newFixedThreadPool和newSingleThreadExectuor默认使用的是一个无限的 LinkedBlockingQueue。如果所有的工作者线程都处于忙碌状态,任务会在队列中等候。如果任务持续快速到达,超过了它们被执行的速度,队 列也会无限制地增加。稳妥的策略是使用有限队列,比如ArrayBlockingQueue或有限的LinkedBlockingQueue以及 PriorityBlockingQueue。
3、对于庞大或无限的池,可以使用SynchronousQueue,完全绕开队列,直接将任务由生产者交给工作者线程
4、可以使用PriorityBlockingQueue通过优先级安排任务


JAVA线程池(ThreadPoolExecutor)源码分析
首先,JAVA 中使用ThreadPoolExecutor的常用方式:
实例代码1
Java代码
Runnable runnable = new CountService(intArr);
ThreadPoolExecutor execute = (ThreadPoolExecutor)Executors.newFixedThreadPool(10 );
//或者使用:ThreadPoolExecutor execute = (ThreadPoolExecutor)Executors.newCachedThreadPool();
execute.submit(runnable);
[java] view plaincopyprint?
Runnable runnable = new CountService(intArr);
ThreadPoolExecutor execute = (ThreadPoolExecutor)Executors.newFixedThreadPool(10);
//或者使用:ThreadPoolExecutor execute = (ThreadPoolExecutor)Executors.newCachedThreadPool();
execute.submit(runnable);


在分析ThreadPoolExecutor源码前,先了解下面两个概念:
1.核心线程(任务): 我们定义的线程,即实现了Runnable接口的类,是我们将要放到线程池中执行的类,如实例代码中的CountService类
2.工作线程 :由线程池中创建的线程,是用来获得核心线程并执行核心线程的线程(比较拗口哦,具体看代码就知道是什么东东了)。

Executors是一个线程池工厂,各种类型的线程池都是通过它来创建的,注意把它和Executor分开,感觉这个线程池工厂命名有点问题。
我们主要分析下我们提交任务的处理逻辑,即’execute.submit(runnable)’的实现。
Submit()方法是在ThreadPoolExecutor继承的抽象类AbstractExecutorService中实现的,具体代码如下:

Java代码
public Future<?> submit(Runnable task) {
if (task == null ) throw new NullPointerException();
//对核心线程的一个包装,RunnableFuture还是一个Runnable
RunnableFuture<Object> ftask = newTaskFor(task, null );
//核心线程执行逻辑
execute(ftask);
return ftask;
}
[java] view plaincopyprint?
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
//对核心线程的一个包装,RunnableFuture还是一个Runnable
RunnableFuture<Object> ftask = newTaskFor(task, null);
//核心线程执行逻辑
execute(ftask);
return ftask;
}

从代码中可以看出,线程的执行逻辑通过execute()完成,而 execute是在AbstractExecutorService的子类ThreadPoolExecutor中实现的。看,一个典型的模板模式!废话 少说,下面看ThreadPoolExecutor中execute()方法中代码:


Java代码
public void execute(Runnable command) {
if (command == null )
throw new NullPointerException();
/*
* command线程运行的整个逻辑在 addIfUnderCorePoolSize(command)方法中实现
* 一般适用于FixedThreadPool
*/
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
/*
* poolSize >= corePoolSize条件成立情景:当创建的为CacheThreadPool时,条件
* 就能成立
*/
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0 )
//两种情况下执行该方法:1.线程池shutdown 2.CacheThreadPool中第一个核心线程的执行
ensureQueuedTaskHandled(command);
}
//CacheThreadPool中线程的执行逻辑
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}
[java] view plaincopyprint?
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* command线程运行的整个逻辑在 addIfUnderCorePoolSize(command)方法中实现
* 一般适用于FixedThreadPool
*/
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
/*
* poolSize >= corePoolSize条件成立情景:当创建的为CacheThreadPool时,条件
* 就能成立
*/
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
//两种情况下执行该方法:1.线程池shutdown 2.CacheThreadPool中第一个核心线程的执行
ensureQueuedTaskHandled(command);
}
//CacheThreadPool中线程的执行逻辑
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}


注意:CachedThreadPool和 FixedThreadPool的逻辑实现都是在ThreadPoolExecutor中实现的。它两的主要区别就是属性corePoolSize以及 workQueue的初始值的不同。具体可自己查看工程类Executors的newFixedThreadPool()和 newCachedThreadPool方法。由于这些初始值的不同,所以实现的逻辑也不同,具体的我在代码中已经注释了。
command线程运行的整个逻辑在 addIfUnderCorePoolSize(command)方法中实现的,
详细请看addIfUnderCorePoolSize(command)源码:


Java代码
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null ;
final ReentrantLock mainLock = this .mainLock;
mainLock.lock();
try {
//poolSize < corePoolSize 即当前工作线程的数量一定要小于你设置的线程最大数量
//CachedThreadPool永远也不会进入该方法,因为它的corePoolSize初始为0
if (poolSize < corePoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null )
return false ;
t.start(); //线程执行了
return true ;
}
[java] view plaincopyprint?
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//poolSize < corePoolSize 即当前工作线程的数量一定要小于你设置的线程最大数量
//CachedThreadPool永远也不会进入该方法,因为它的corePoolSize初始为0
if (poolSize < corePoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start(); //线程执行了
return true;
}


看’t.start()’,这表示工作线程启动了,工作线程t启动的前提条件是’t = addThread(firstTask); ‘返回值t必须不为null。好了,现在想看看java线程池中工作线程是怎么样的吗?请看addThread方法:

Java代码
private Thread addThread(Runnable firstTask) {
//Worker就是典型的工作线程,所以的核心线程都在工作线程中执行
Worker w = new Worker(firstTask);
//采用默认的线程工厂生产出一线程。注意就是设置一些线程的默认属性,如优先级、是否为后台线程等
Thread t = threadFactory.newThread(w);
if (t != null ) {
w.thread = t;
workers.add(w);
//没生成一个工作线程 poolSize加1,但poolSize等于最大线程数corePoolSize时,则不能再生成工作线程
int nt = ++poolSize;
if (nt > largestPoolSize)
largestPoolSize = nt;
}
return t;
}
[java] view plaincopyprint?
private Thread addThread(Runnable firstTask) {
//Worker就是典型的工作线程,所以的核心线程都在工作线程中执行
Worker w = new Worker(firstTask);
//采用默认的线程工厂生产出一线程。注意就是设置一些线程的默认属性,如优先级、是否为后台线程等
Thread t = threadFactory.newThread(w);
if (t != null) {
w.thread = t;
workers.add(w);
//没生成一个工作线程 poolSize加1,但poolSize等于最大线程数corePoolSize时,则不能再生成工作线程
int nt = ++poolSize;
if (nt > largestPoolSize)
largestPoolSize = nt;
}
return t;
}


看见没,Worker就是工作线程类,它是ThreadPoolExecutor中的一个内部类。下面,我们主要分析Worker类,如了解了 Worker类,那基本就了解了java线程池的整个原理了。不用怕,Worker类的逻辑很简单,它其实就是一个线程,实现了Runnable接口的, 所以,我们先从run方法入手,run方法源码如下:


Java代码
public void run() {
try {
Runnable task = firstTask;
firstTask = null ;
/**
* 注意这段while循环的执行逻辑,没执行完一个核心线程后,就会去线程池
* 队列中取下一个核心线程,如取出的核心线程为null,则当前工作线程终止
*/
while (task != null || (task = getTask()) != null ) {
runTask(task); //你所提交的核心线程(任务)的运行逻辑
task = null ;
}
} finally {
workerDone(this ); // 当前工作线程退出
}
}
}
[java] view plaincopyprint?
public void run() {
try {
Runnable task = firstTask;
firstTask = null;
/**
* 注意这段while循环的执行逻辑,没执行完一个核心线程后,就会去线程池
* 队列中取下一个核心线程,如取出的核心线程为null,则当前工作线程终止
*/
while (task != null || (task = getTask()) != null) {
runTask(task); //你所提交的核心线程(任务)的运行逻辑
task = null;
}
} finally {
workerDone(this); // 当前工作线程退出
}
}
}


从源码中可看出,我们所提交的核心线程(任务)的逻辑是在 Worker中的runTask()方法中实现的。这个方法很简单,自己可以打开看看。这里要注意一点,在runTask()方法中执行核心线程时是调用 核心线程的run()方法,这是一个寻常方法的调用,千万别与线程的启动(start())混合了。这里还有一个比较重要的方法,那就是上述代码中 while循环中的getTask()方法,它是一个从池队列中取的核心线程(任务)的方法。具体代码如下:


Java代码
Runnable getTask() {
for (;;) {
try {
int state = runState;
if (state > SHUTDOWN)
return null ;
Runnable r;
if (state == SHUTDOWN) //帮助清空队列
r = workQueue.poll();
/*
* 对于条件1,如果可以超时,则在等待keepAliveTime时间后,则返回一null对象,这时就
* 销毁该工作线程,这就是CachedThreadPool为什么能回收空闲线程的原因了。
* 注意以下几点:1.这种功能情况一般不可能在fixedThreadPool中出现
* 2.在使用CachedThreadPool时,条件1一般总是成立,因为CachedThreadPool的corePoolSize
* 初始为0
*/
else if (poolSize > corePoolSize || allowCoreThreadTimeOut) //------------------条件1
r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
else
r = workQueue.take(); //如果队列不存在任何元素 则一直等待。 FiexedThreadPool典型模式----------条件2
if (r != null )
return r;
if (workerCanExit()) { //--------------------------条件3
if (runState >= SHUTDOWN) // Wake up others
interruptIdleWorkers();
return null ;
}
// Else retry
} catch (InterruptedException ie) {
// On interruption, re-check runState
}
}
}
[java] view plaincopyprint?
Runnable getTask() {
for (;;) {
try {
int state = runState;
if (state > SHUTDOWN)
return null;
Runnable r;
if (state == SHUTDOWN) //帮助清空队列
r = workQueue.poll();
/*
* 对于条件1,如果可以超时,则在等待keepAliveTime时间后,则返回一null对象,这时就
* 销毁该工作线程,这就是CachedThreadPool为什么能回收空闲线程的原因了。
* 注意以下几点:1.这种功能情况一般不可能在fixedThreadPool中出现
* 2.在使用CachedThreadPool时,条件1一般总是成立,因为CachedThreadPool的corePoolSize
* 初始为0
*/
else if (poolSize > corePoolSize || allowCoreThreadTimeOut) //------------------条件1
r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
else
r = workQueue.take(); //如果队列不存在任何元素 则一直等待。 FiexedThreadPool典型模式----------条件2
if (r != null)
return r;
if (workerCanExit()) { //--------------------------条件3
if (runState >= SHUTDOWN) // Wake up others
interruptIdleWorkers();
return null;
}
// Else retry
} catch (InterruptedException ie) {
// On interruption, re-check runState
}
}
}


从这个方法中,我们需要了解一下几点:
1.CachedThreadPool获得任务逻辑是条件1 ,条件1的处理逻辑请看注释,CachedThreadPool执行条件1的原因是:CachedThreadPool的corePoolSize时刻为0。

2.FixedThreadPool执行的逻辑为条件2 ,从’workQueue.take()’中我们就明白了为什么FixedThreadPool不会释放工作线程的原因了(除非你关闭线程池)。

最后,我们了解下Worker(工作线程)终止时的处理吧,这个对理解CachedThreadPool有帮助,具体代码如下:

Java代码
/**
* 工作线程退出要处理的逻辑
* @param w
*/
void workerDone(Worker w) {
final ReentrantLock mainLock = this .mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w); //从工作线程缓存中删除
if (--poolSize == 0 ) //poolSize减一,这时其实又可以创建工作线程了
tryTerminate(); //尝试终止
} finally {
mainLock.unlock();
}
}
[java] view plaincopyprint?
/**
* 工作线程退出要处理的逻辑
* @param w
*/
void workerDone(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w); //从工作线程缓存中删除
if (--poolSize == 0) //poolSize减一,这时其实又可以创建工作线程了
tryTerminate(); //尝试终止
} finally {
mainLock.unlock();
}
}


注意workDone()方法中的tyrTerminate()方法,它是你以后理解线程池中shuDown()以及CachedThreadPool原理的关键,具体代码如下:


Java代码
private void tryTerminate() {
//终止的前提条件就是线程池里已经没有工作线程(Worker)了
if (poolSize == 0 ) {
int state = runState;
/**
* 如果当前已经没有了工作线程(Worker),但是线程队列里还有等待的线程任务,则创建一个
* 工作线程来执行线程队列中等待的任务
*/
if (state < STOP && !workQueue.isEmpty()) {
state = RUNNING; // disable termination check below
Thread t = addThread(null );
if (t != null )
t.start();
}
//设置池状态为终止状态
if (state == STOP || state == SHUTDOWN) {
runState = TERMINATED;
termination.signalAll();
terminated();
}
}
}
[java] view plaincopyprint?
private void tryTerminate() {
//终止的前提条件就是线程池里已经没有工作线程(Worker)了
if (poolSize == 0) {
int state = runState;
/**
* 如果当前已经没有了工作线程(Worker),但是线程队列里还有等待的线程任务,则创建一个
* 工作线程来执行线程队列中等待的任务
*/
if (state < STOP && !workQueue.isEmpty()) {
state = RUNNING; // disable termination check below
Thread t = addThread(null);
if (t != null)
t.start();
}
//设置池状态为终止状态
if (state == STOP || state == SHUTDOWN) {
runState = TERMINATED;
termination.signalAll();
terminated();
}
}
}
原文链接:http://blog.csdn.net/longeremmy/article/details/8225498
加载中
返回顶部
顶部