对Java线程池使用的总结
为了账号安全，请及时绑定邮箱和手机对Java线程池使用的总结& & 最近的项目中，遇到了一些需要频繁使用sql查询，写入文件，可以拆分子任务的情况。为了提高程序吞吐量，我使用了线程池。&&&&一开始，考虑将用户按照数量进行分片，因为在数据库查询中，oracle对where in（）有不得超过1000个查询量的限制，所以考虑将每900个用户分一片，每片为一个task，交给fix线程池处理。&&&&但是每个task又有查询优惠券和查询待评论数两个较大的子任务，这两个子任务需要大量的sql查询，于是又考虑将这两个子任务也封装为task，交给线程池处理。但因为主任务的执行依赖子任务的结果，如果使用同一个线程池，则子任务被提交后，work队列中被执行的任务还是主任务，cpu一直在先提交的主任务上等待Future.get（）的返回，子任务得不到cpu资源去执行，一直在任务队列中等待，这将造成程序的死等待。所以将线程池由fix改为cache，希望提交的任务能得到cpu时间，不会一直在队列中等待。后来这里也引发了问题，将在下一篇文章中说明。& &当用户的账单数据被计算出来后，需要调用模板中心生成邮件，还需要将生成的邮件保存到磁盘上，这是两种不同的io密集型任务，一个是在socket上等待，一个是在本地io上等待。考虑到如果继续提交到cache线程池，那么线程池会为每个task生成一个线程，将耗费大量资源，cpu将频繁切换线程，降低了程序的吞吐量。因此新建一个fix线程池，将这些后续任务提交给fix线程池处理，线程池使用固定数量的work去跑，即能在不同阻塞情况下，让程序可以继续运行，也避免了创建大量thread的资源浪费。& & 其实最后程序里用了五个线程池，分级使用的原因有以下考虑：& & 为了提高程序执行效率，可以将用户先按照语言分类，然后再按照900人一片进行分片，每片任务中，又涉及到两个频繁查询数据库的子任务，每片处理完后，又需要进行网络io生产邮件和磁盘io保存邮件。如果用相同的线程池，则上级任务生产的子任务提交fix线程池后，因为work队列还在被上级任务占用，不同类型的io操作都将在task队列中等待，无法提高系统吞吐量。将下级任务提交到其他线程池后，下级任务就能有立即执行的机会，进行网络io和磁盘读写，提高了运行效率。上一条：下一条：991点赞收藏分享：&猜你喜欢12345681234567891011121314151617181920212223242526272829Copyright (C)
All Rights Reserved | 皖B2-最近在看java并发方面的一点知识，看了几个博客好蛮好的，收集一下：
java并发可以看看上的资料
本篇博客转自：
来看一下线程池的框架图，如下：
1、Executor任务提交接口与Executors工具类
　　Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。Executor框架是一个根据一组执行策略调用，调度，执行和控制的异步任务的框架。Executor存在的目的是提供一种将”任务提交”与”任务如何运行”分离开来的机制。定义如下：
public interface Executor {
void execute(Runnable command);
　　虽然只有一个方法，但是却为灵活且强大的异步任务执行框架提供了基础。它提供了一种标准的方法将任务的提交过程与执行过程解耦开来，并用Runnable来表示任务。那么我们怎么得到Executor对象呢？这就是接下来要介绍的Exectors了。
Executors为Executor，ExecutorService，ScheduledExecutorService，ThreadFactory和Callable类提供了一些工具方法，类似于集合中的Collections类的功能。Executors方便的创建线程池。
　　1&newCachedThreadPool
：该线程池比较适合没有固定大小并且比较快速就能完成的小任务，它将为每个任务创建一个线程。那这样子它与直接创建线程对象（new Thread()）有什么区别呢？看到它的第三个参数60L和第四个参数TimeUnit.SECONDS了吗？好处就在于60秒内能够重用已创建的线程。下面是Executors中的newCachedThreadPool()的源代码：　　
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue&Runnable&());
　　2& newFixedThreadPool使用的Thread对象的数量是有限的,如果提交的任务数量大于限制的最大线程数，那么这些任务讲排队，然后当有一个线程的任务结束之后，将会根据调度策略继续等待执行下一个任务。下面是Executors中的newFixedThreadPool()的源代码：　
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue&Runnable&());
　　3&newSingleThreadExecutor　就是线程数量为1的FixedThreadPool,如果提交了多个任务，那么这些任务将会排队，每个任务都会在下一个任务开始之前运行结束，所有的任务将会使用相同的线程。下面是Executors中的newSingleThreadExecutor()的源代码：　　
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue&Runnable&()));
　　4&newScheduledThreadPool创建一个固定长度的线程池，而且以延迟或定时的方式来执行任务。
　　通过如上配置的线程池的创建方法源代码，我们可以发现：
　　　　1& 除了CachedThreadPool使用的是直接提交策略的缓冲队列以外，其余两个用的采用的都是无界缓冲队列，也就说，FixedThreadPool和SingleThreadExecutor创建的线程数量就不会超过 corePoolSize。
　　2& 我们可以再来看看三个线程池采用的ThreadPoolExecutor构造方法都是同一个，使用的都是默认的ThreadFactory和handler:
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue&Runnable& workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
　　也就说三个线程池创建的线程对象都是同组，优先权等级为正常的Thread.NORM_PRIORITY（5）的非守护线程，使用的被拒绝任务处理方式是直接抛出异常的AbortPolicy策略（前面有介绍）。
2、ExecutorService任务周期管理接口
　　Executor的实现通常都会创建线程来执行任务，但是使用异步方式来执行任务时，由于之前提交任务的状态不是立即可见的，所以如果要关闭应用程序时，就需要将受影响的任务状态反馈给应用程序。
　　为了解决执行服务的生命周期问题，Executor扩展了EecutorService接口，添加了一些用于生命周期管理的方法。如下：
public interface ExecutorService extends Executor {
void shutdown();
List&Runnable& shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedE
3、ThreadPoolExecutor线程池实现类
　　先来看一下这个类中定义的重要变量，如下：
private final BlockingQueue&Runnable& workQ
private final ReentrantLock mainLock = new ReentrantLock();
private final HashSet&Worker& workers = new HashSet&Worker&();
private final Condition termination = mainLock.newCondition();
private int largestPoolS
private long completedTaskC
private volatile ThreadFactory threadF
private volatile RejectedExecutionH
private volatile long keepAliveT
private volatile boolean allowCoreThreadTimeO
private volatile int corePoolS
private volatile int maximumPoolS
　　其中有几个重要的规则需要说明一下：
　　1& corePoolSize与maximumPoolSize
由于ThreadPoolExecutor 将根据 corePoolSize和 maximumPoolSize设置的边界自动调整池大小，当新任务在方法 execute(java.lang.Runnable) 中提交时：
　　（1）如果运行的线程少于 corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的；
　　（2）如果设置的corePoolSize 和 maximumPoolSize相同，则创建的线程池是大小固定的，如果运行的线程与corePoolSize相同，当有新请求过来时，若workQueue未满，则将请求放入workQueue中，等待有空闲的线程去从workQueue中取任务并处理
　　（3）如果运行的线程多于 corePoolSize 而少于 maximumPoolSize，则仅当队列满时才创建新线程才创建新的线程去处理请求；
　　（4）如果运行的线程多于corePoolSize 并且等于maximumPoolSize，若队列已经满了，则通过handler所指定的策略来处理新请求；
　　（5）如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务
　　也就是说，处理任务的优先级为：
　　（1） 核心线程corePoolSize & 任务队列workQueue & 最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
　　（2）当池中的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁。
　　2& workQueue 线程池所使用的缓冲队列，该缓冲队列的长度决定了能够缓冲的最大数量，缓冲队列有三种通用策略：
　　1) 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;
　　2) 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;
　　3&ThreadFactory
使用 ThreadFactory 创建新线程。如果没有另外说明，则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程，并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。通过提供不同的 ThreadFactory，可以改变线程的名称、线程组、优先级、守护进程状态等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程，则执行程序将继续运行，但不能执行任何任务。
public interface ThreadFactory {
Thread newThread(Runnable r);
　　而构造方法中的threadFactory对象，是通过 Executors.defaultThreadFactory()返回的。Executors.java中的defaultThreadFactory()源码如下：
public static ThreadFactory defaultThreadFactory() {
return new DefaultThreadFactory();
　　在DefaultThreadFactory类中实现了ThreadFactory接口并对其中定义的方法进行了实现，如下：
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadG
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String nameP
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
　　4&RejectedExecutionHandler
　　当Executor已经关闭（即执行了executorService.shutdown()方法后），并且Executor将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法execute()中提交的新任务将被拒绝.
　　在以上述情况下，execute 方法将调用其 RejectedExecutionHandler 的RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：
　　1) 在默认的 ThreadPoolExecutor.AbortPolicy
处理程序遭到拒绝将抛出运行时 RejectedExecutionE
　　2) 在 ThreadPoolExecutor.CallerRunsPolicy
线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度
　　3) 在 ThreadPoolExecutor.DiscardPolicy
不能执行的任务将被删除;
　　4) 在 ThreadPoolExecutor.DiscardOldestPolicy
如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。
线程池默认会采用的是defaultHandler策略。首先看defaultHandler的定义：
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
　　看一下其他拒绝策略的具体实现。
class MyRunnable implements Runnable {
public MyRunnable(String name) {
this.name =
public void run() {
System.out.println(this.name + " is running.");
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
　　如上是一个测试任务的例子，下面编写4个测试用例来测试。
1.DiscardPolicy 示例
public class DiscardPolicyDemo {
private static final int THREADS_SIZE = 1;
private static final int CAPACITY = 1;
public static void main(String[] args) throws Exception {
ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue&Runnable&(CAPACITY));
pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
for (int i = 0; i & 10; i++) {
Runnable myrun = new MyRunnable("task-"+i);
pool.execute(myrun);
pool.shutdown();
　　线程池pool的”最大池大小”和”核心池大小”都为1(THREADS_SIZE)，这意味着”线程池能同时运行的任务数量最大只能是1”。
　　线程池pool的阻塞队列是，ArrayBlockingQueue是一个有界的阻塞队列，ArrayBlockingQueue的容量为1。这也意味着线程池的阻塞队列只能有一个线程池阻塞等待。
　　根据”“中分析的execute()代码可知：线程池中共运行了2个任务。第1个任务直接放到Worker中，通过线程去执行；第2个任务放到阻塞队列中等待。其他的任务都被丢弃了！
2.DiscardOldestPolicy 示例
public class DiscardOldestPolicyDemo {
private static final int THREADS_SIZE = 1;
private static final int CAPACITY = 1;
public static void main(String[] args) throws Exception {
ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,
new ArrayBlockingQueue&Runnable&(CAPACITY));
pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
for (int i = 0; i & 10; i++) {
Runnable myrun = new MyRunnable("task-"+i);
pool.execute(myrun);
pool.shutdown();
运行结果：
task-0 is running.
task-9 is running.
将”线程池的拒绝策略”由DiscardPolicy修改为DiscardOldestPolicy之后，当有任务添加到线程池被拒绝时，线程池会丢弃阻塞队列中末尾的任务，然后将被拒绝的任务添加到末尾。
3.AbortPolicy 示例
public class AbortPolicyDemo {
private static final int THREADS_SIZE = 1;
private static final int CAPACITY = 1;
public static void main(String[] args) throws Exception {
ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,
new ArrayBlockingQueue&Runnable&(CAPACITY));
pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i & 10; i++) {
Runnable myrun = new MyRunnable("task-"+i);
pool.execute(myrun);
} catch (RejectedExecutionException e) {
e.printStackTrace();
pool.shutdown();
(某一次)运行结果：
java.util.concurrent.RejectedExecutionException
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1774)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:768)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:656)
at AbortPolicyDemo.main(AbortPolicyDemo.java:27)
task-0 is running.
task-1 is running.
　　将”线程池的拒绝策略”由DiscardPolicy修改为AbortPolicy之后，当有任务添加到线程池被拒绝时，会抛出RejectedExecutionException。
4.CallerRunsPolicy 示例
public class CallerRunsPolicyDemo {
private static final int THREADS_SIZE = 1;
private static final int CAPACITY = 1;
public static void main(String[] args) throws Exception {
ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,
new ArrayBlockingQueue&Runnable&(CAPACITY));
pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 0; i & 10; i++) {
Runnable myrun = new MyRunnable("task-"+i);
pool.execute(myrun);
pool.shutdown();
(某一次)运行结果：
task-2 is running.
task-3 is running.
task-4 is running.
task-5 is running.
task-6 is running.
task-7 is running.
task-8 is running.
task-9 is running.
task-0 is running.
task-1 is running.
　　将”线程池的拒绝策略”由DiscardPolicy修改为CallerRunsPolicy之后，当有任务添加到线程池被拒绝时，线程池会将被拒绝的任务添加到”线程池正在运行的线程”中取运行。
　　线程池能够复用线程，减少线程创建，销毁，恢复等状态切换的开销，提高程序的性能。一个线程池管理了一组工作线程，同时它还包括了一个用于放置等待执行的任务的队列。
　　ThreadPoolExecutor类中定义了一些与线程状态与活动线程数相关的一些变量，如下：
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY
= (1 && COUNT_BITS) - 1;
private static final int RUNNING
= -1 && COUNT_BITS;
private static final int SHUTDOWN
0 && COUNT_BITS;
private static final int STOP
1 && COUNT_BITS;
private static final int TIDYING
2 && COUNT_BITS;
private static final int TERMINATED =
3 && COUNT_BITS;
　　由如上可知：
　　ctl是一个AtomicInteger类型的原子对象。ctl记录了”线程池中的任务数量”和”线程池状态”2个信息。ctl共包括32位。其中，高3位表示”线程池状态”，低29位表示”线程池中的任务数量”。
　　线程池各个状态之间的切换如下图所示：
　　线程池各个状态间的转换的详细解释如下所示。
　　1& RUNNING(111) -& SHUTDOWN(000) : 调用了shutdown方法，线程池实现了finalize方法，在里面调用了shutdown方法，因此shutdown可能是在finalize中被隐式调用的
　　2& (RUNNING(111) or SHUTDOWN(000)) -& STOP(001) 调用了shutdownNow方法
　　3& SHUTDOWN(000) -& TIDYING(010) :　当队列和线程池均为空的时候
　　4& STOP(001) -& TIDYING(010) : 当线程池为空的时候
　　5& TIDYING(010) -& TERMINATED(011) : terminated()方法调用完毕
　　说明：扩号后的3位数字表示ctl的高3位二进制值，并不关注低29位二进制的值
　　还有一些对常量的操作方法，只说明部分，其他的有兴趣自己可以去查看，如下：
private static int runStateOf(int c)
{ return c & ~CAPACITY; }
private static int workerCountOf(int c)
{ return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | }
　　来看一下ThreadPoolExecutor()中最主要的一个构造函数,如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue&Runnable& workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize & 0 || maximumPoolSize &= 0 || maximumPoolSize & corePoolSize ||
keepAliveTime & 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolS
this.maximumPoolSize = maximumPoolS
this.workQueue = workQ
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadF
this.handler =
　　调用Executors方法中的几个方法，如newCachedThreadPool()、newFixedThreadPool()时，都会间接调用上面的构造方法来初始化所有的线程池相关变量。
1、创建线程池并执行任务
有了Executor对象后，就可以调用execute()方法执行任务了。方法的源代码如下：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) & corePoolSize) {
if (addWorker(command, true))
c = ctl.get();
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
else if (!addWorker(command, false))
reject(command);
　　当前活动的线程小于corePoolSize了，那么等于和大于corePoolSize怎么处理呢？
当前活动的线程数量 &= corePoolSize 的时候，都是优先添加到队列中，直到队列满了才会去创建新的线程，在这里第27 行的if语句已经体现出来了。这里利用了&&的特性，只有当第一个条件会真时才会去判断第二个条件，第一个条件是isRunning()，判断线程池是否处于RUNNING状态，因为只有在这个状态下才会接受新任务，否则就拒绝，如果正处于RUNNING状态，那么就加入队列，如果加入失败可能就是队列已经满了，这时候直接执行第29行。
　　2& 在execute()方法中，当 当前活动的线程数量 & corePoolSize 时，会执行addWorker()方法，关于addWorker()，它是用来直接新建线程用的，之所以叫addWorker而不是addThread是因为在线程池中，所有的线程都用一个Worker对象包装着，来看一下这个方法：
* 创建并执行新线程
* firstTack 用于指定新增的线程执行的第一个任务
true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，
false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize
* 是否成功新增一个线程
private boolean addWorker(Runnable firstTask, boolean core) {
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
if (rs &= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc &= CAPACITY ||
wc &= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
c = ctl.get();
if (runStateOf(c) != rs)
Worker w = new Worker(firstTask);
Thread t = w.
final ReentrantLock mainLock = this.mainL
mainLock.lock();
int c = ctl.get();
int rs = runStateOf(c);
if (t == null ||
(rs &= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null))) {
decrementWorkerCount();
tryTerminate();
return false;
workers.add(w);
int s = workers.size();
if (s & largestPoolSize)
largestPoolSize =
} finally {
mainLock.unlock();
t.start();
if (runStateOf(ctl.get()) == STOP && ! t.isInterrupted())
t.interrupt();
return true;
　　那么在创建线程的时候，线程执行的是什么的呢？
　　我们前面提到Worker继承的其实也是Runnable，它在创建线程的时候是以自身作为任务传进先创建的线程中的，这段比较简单，我就不一一注释了，只是给出源代码给大家看吧。
Worker(Runnable firstTask) {
this.firstTask = firstT
this.thread = getThreadFactory().newThread(this);
　　它以自身的对象作为线程任务传进去，那么它的run方法又是怎样的呢？
public void run() {
runWorker(this);
竟然只有一句话调用runWorker()方法，这个可是重头戏，我们来看看，究竟运行的是什么。
* 执行Worker中的任务，它的执行流程是这样的：
* 若存在第一个任务，则先执行第一个任务，否则，从队列中拿任务，不断的执行，
* 直到getTask()返回null或执行任务出错（中断或任务本身抛出异常），就退出while循环。
final void runWorker(Worker w) {
Runnable task = w.firstT
w.firstTask = null;
boolean completedAbruptly = true;
while (task != null || (task = getTask()) != null) {
clearInterruptsForTaskRun();
beforeExecute(w.thread, task);
Throwable thrown = null;
task.run();
} catch (RuntimeException x) {
thrown = throw
} catch (Error x) {
thrown = throw
} catch (Throwable x) {
thrown = throw new Error(x);
} finally {
afterExecute(task, thrown);
} finally {
task = null;
w.completedTasks++;
w.unlock();
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
　　下面就是线程在执行任务之前对线程池状态的一次判断：
* 对线程的结束做一些清理和数据同步
* w 封装线程的Worker
* completedAbruptly 表示该线程是否结束于异常
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly)
decrementWorkerCount();
final ReentrantLock mainLock = this.mainL
mainLock.lock();
completedTaskCount += w.completedT
workers.remove(w);
} finally {
mainLock.unlock();
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolS
if (min == 0 && ! workQueue.isEmpty())
if (workerCountOf(c) &= min)
addWorker(null, false);
　　前面我们的方法遇见过很多次tryTerminate()方法，到底他是怎样尝试结束线程池的呢？
* 执行该方法，根据线程池状态进行
判断是否结束线程池
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
if (workerCountOf(c) != 0) {
interruptIdleWorkers(ONLY_ONE);
final ReentrantLock mainLock = this.mainL
mainLock.lock();
if (pareAndSet(c, ctlOf(TIDYING, 0))) {
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
} finally {
mainLock.unlock();
2、关闭线程池
　　关闭时使用shutdown()方法，源码如下：
public void shutdown() {
final ReentrantLock mainLock = this.mainL
mainLock.lock();
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown();
} finally {
mainLock.unlock();
tryTerminate();
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：20252次
排名：千里之外
原创：27篇
转载：14篇
评论：11条
(1)(1)(1)(3)(3)(2)(2)(6)(2)(1)(1)(4)(1)(1)(2)(2)(1)(1)(4)(3)