1 线程池介绍
1.1 线程池概念
Sun在Java5中，对Java线程的类库做了大量的扩展，其中线程池就是Java5的新特征之一，除了线程池之外，还有很多多线程相关的内容，为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序，线程部分的新增内容显得尤为重要。
有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类，熟悉这部分API特征是一项艰难的学习过程
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。
1.2 线程池好处
合理利用线程池能够带来三个好处
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。
2 线程池的使用
2.1 线程池的创建
2.1.1 通过ThreadPoolExecutor创建
我们可以通过ThreadPoolExecutor来创建一个线程池
new ThreadPoolExecutor(corePoolSize, maximumPoolSize,keepAliveTime, timeUnit,
runnableTaskQueue, threadFactory,handler);
创建一个线程池需要输入几个参数：
corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列：ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序，必须指定队列大小。LinkedBlockingQueue：一个基于链表结构的有界阻塞队列，此队列按FIFO（先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()和newSingleThreadExecutor使用了这个队列，注意：如果不指定队列大小，就默认为Integer.MAX_VALUE。SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。PriorityBlockingQueue：一个具有优先级得无限阻塞队列。存放在PriorityBlockingQueue中的元素必须实现Comparable接口，这样才能通过实现compareTo()方法进行排序。优先级最高的元素将始终排在队列的头部；PriorityBlockingQueue不会保证优先级一样的元素的排序，也不保证当前队列中除了优先级最高的元素以外的元素，随时处于正确排序的位置。DelayedWorkQueue:一个使用优先级队列实现的无界阻塞队列，静态工厂方法Executors.newScheduledThreadPool使用
基于二叉堆实现，同时具备：无界队列、阻塞队列、优先队列的特征。DelayQueue延迟队列中存放的对象，必须是实现Delayed接口的类对象。通过执行时延从队列中提取任务，时间没到任务取不出来。LinkedBlockingDeque： 双端队列。基于链表实现，既可以从尾部插入/取出元素，还可以从头部插入元素/取出元素。LinkedTransferQueue： 由链表结构组成的无界阻塞队列。这个队列比较特别的时，采用一种预占模式，意思就是消费者线程取元素时，如果队列不为空，则直接取走数据，若队列为空，那就生成一个节点（节点元素为null）入队，然后消费者线程被等待在这个节点上，后面生产者线程入队时发现有一个元素为null的节点，生产者线程就不入队了，直接就将元素填充到该节点，并唤醒该节点等待的线程，被唤醒的消费者线程取走元素。
maximumPoolSize（线程池最大大小）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字，Debug和定位问题时非常又帮助。RejectedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略：AbortPolicy（默认）： 丢弃任务并抛出RejectedExecutionException异常。CallerRunsPolicy：只用调用者所在线程来运行任务。DiscardOldestPolicy：丢弃队列里最早进入一个任务，并执行当前任务。将当前处于等待队列列头的等待任务强行取出，然后再试图将当前被拒绝的任务提交到线程池执行。DiscardPolicy：不处理，丢弃掉。- 自定义策略：当然也可以根据应用场景需要来实现
RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。
keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS），小时（HOURS），分钟（MINUTES），毫秒(MILLISECONDS)，微秒(MICROSECONDS, 千分之一毫秒)和毫微秒(NANOSECONDS, 千分之一微秒)
自定义连接池稍微麻烦些，不过通过创建的ThreadPoolExecutor线程池对象，可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等
具体示例：
ThreadPoolExecutor thread
= new ThreadPoolExecutor(1, 5, 5, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
new ThreadFactoryBuilder().setNamePrefix("Pool-" + "线程名字").setDaemon(false).build(),
new ThreadPoolExecutor.CallerRunsPolicy());
2.1.2 通过Executors方式创建
Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：
newCachedThreadPool:创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
ExecutorService pool = Executors.newCachedThreadPool();
newFixedThreadPool:创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
ExecutorService pool = Executors.newFixedThreadPool(2);
newScheduledThreadPool:创建一个定长线程池，支持定时及周期性任务执行
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
将线程放入池中进行执行
pool.execute(new MyThread());
使用延迟执行风格的方法
pool.schedule(new MyThread(), 10, TimeUnit.MILLISECONDS);
class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行。。。");
}
}
延迟+定时执行
pool.scheduleAtFixedRate(newRunnable(){
@Override
public void run() {
System.out.println("延迟 1 秒后每三秒执行一次");
}
},1,3,TimeUnit.SECONDS);
newSingleThreadExecutor:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
ExecutorService pool = Executors.newSingleThreadExecutor();
2.1.3 线程池初始化和容量调整
默认情况下，创建线程池之后，线程池中是没有线程的，需要提交任务之后才会创建线程。
在实际中如果需要线程池创建之后立即创建线程，可以通过以下两个方法办到：
prestartCoreThread()：boolean prestartCoreThread()，初始化一个核心线程prestartAllCoreThreads()：int prestartAllCoreThreads()，初始化所有核心线程，并返回初始化的线程数
线程池容量调整
ThreadPoolExecutor提供了动态调整线程池容量大小的方法：
setCorePoolSize：设置核心池大小setMaximumPoolSize：设置线程池最大能创建的线程数目大小
当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还可能立即创建新的线程来执行任务。
2.2 线程池提交的返回值
2.2.1 无返回值
2.2.1.1 execute提交
可以使用execute提交的任务，但是execute方法没有返回值，所以无法判断任务是否被线程池执行成功。通过以下代码可知execute方法输入的任务是一个Runnable类的实例
threadsPool.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
});
2.2.1.2 实现Runnable接口
无返回值的任务必须Runnable接口重写run方法，方法的异常只能在内部消化，不能继续上抛
2.2.2 有返回值
2.2.2.1 submit提交
我们也可以使用submit方法来提交任务，它会返回一个future,那么我们可以通过这个future来判断任务是否执行成功，通过future的get方法来获取返回值， get方法会阻塞住直到任务完成 ，而使用get(long timeout, TimeUnit unit)方法则会阻塞一段时间后立即返回，这时有可能任务没有执行完。
try {
Object s = future.get();
} catch (InterruptedException e) {
// 处理中断异常
} catch (ExecutionException e) {
// 处理无法执行任务异常
} finally {
// 关闭线程池
executor.shutdown();
}
2.2.2.2 实现Callable接口
返回值的任务必须实现Callable接口重写call方法且方法允许抛出异常
要想有返回值，那么submit的组合：
submit(Callable<T> task)能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用submit(Runnable task, T result)能通过传入的载体result间接获得线程的返回值。submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null
2.2.3 使用例子
public void testFuture() throws InterruptedException {
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
NewTask newTask = new NewTask();
Future<Integer> result = executor.submit(task);
Future<String> ends = executor.submit(newTask);
executor.shutdown();
System.out.println("主线程开始运行");
System.out.println("主线程做一些复杂任务");
Thread.sleep(10000);
System.out.println("主线程需要子线程的计算结果");
try {
System.out.println("主线程得到子线程的结果："+result.get());
System.out.println("主线程需要第二个子线程的数据:"+ends.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("所有均完毕");
}
class Task implements Callable<Integer>{
public Integer call() throws Exception {
System.out.println("子线程计算开始");
Thread.sleep(3000);
int sum = 0;
for (int i=0;i<100000;i++){
sum += i ;
}
System.out.println("子线程已经计算完毕");
return sum;
}
}
class NewTask implements Callable<String>{
public String call() throws Exception {
System.out.println("第二个子线程已经运行完毕");
return "success";
}
}
2.2.4 invokeAll和invokeAny
invokeAll和invokeAny区别：
invokeAll触发执行任务列表，返回的结果顺序也与任务在任务列表中的顺序一致。所有线程执行完任务后才返回结果。如果设置了超时时间，未超时完成则正常返回结果，如果超时未完成则报异常。invokeAny将第一个得到的结果作为返回值，然后立刻终止所有的线程。如果设置了超时时间，未超时完成则正常返回结果，如果超时未完成则报超时异常
submit、execute、invokeAll和invokeAny区别：
invallkeAll和invokeAny会直接造成主线程阻塞（需要设置超时时间）。等待所有任务执行完成后返回结果，主线程继续执行。submit不会造成主线程阻塞，在后面执行get方法的时候阻塞。超时时间在get里面设置。execute会新开启线程直接执行任务，不会阻塞主线程，但无返回结果
2.3 线程池的关闭
我们可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池，但是它们的实现原理不同：
shutdown的原理是只是将线程池的状态设置成SHUTDOWN状态，然后 中断所有没有正在执行任务的线程 。
shutdownNow的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。shutdownNow会首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表。
只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于我们应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow
2.4 线程池状态分析
线程池和线程的状态是不一样的哈，线程池有这几个状态：RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED
//线程池状态
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;
线程池各个状态切换状态图如下：
RUNNING
该状态的线程池会接收新任务，并处理阻塞队列中的任务;
调用线程池的shutdown()方法，可以切换到SHUTDOWN状态;
调用线程池的shutdownNow()方法，可以切换到STOP状态;SHUTDOWN
该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
队列为空，并且线程池中执行的任务也为空,进入TIDYING状态;STOP
该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
线程池中执行的任务为空,进入TIDYING状态;TIDYING
该状态表明所有的任务已经运行终止，记录的任务数量为0。
terminated()执行完毕，进入TERMINATED状态TERMINATED
该状态表示线程池彻底终止
3 线程池的分析
3.1 流程分析
Java线程池主要工作流程：
工作流程模型图参考链接
当提交一个新任务到线程池时，线程池的处理流程如下：
- 首先线程池判断
基本线程池是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。 - 其次线程池判断
工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。 - 最后线程池判断
整个线程池是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务。
另外：当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
线程池内线程数量小于等于coreSize的部分称为核心池，核心池是线程池的常驻部分，内部的线程一般不会被销毁，我们提交的任务也应该绝大部分都由核心池内的线程来执行，但是当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭
3.2 源码分析
上面的流程分析让我们很直观的了解的线程池的工作原理，让我们再通过源代码来看看是如何实现的。线程池执行任务的方法如下：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//如果线程数小于基本线程数，则创建线程并执行当前任务
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
//如线程数大于等于基本线程数或线程创建失败，则将当前任务放到工作队列中。
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
//如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许的线程数量，则创建一个线程执行任务。
else if (!addIfUnderMaximumPoolSize(command))
//抛出RejectedExecutionException异常
reject(command); // is shutdown or saturated
}
}
工作线程
线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。我们可以从Worker的run方法里看到这点：
public void run() {
try {
Runnable task = firstTask;
firstTask = null;
while (task != null || (task = getTask()) != null) {
runTask(task);
task = null;
}
} finally {
workerDone(this);
}
}
3.3 解读线程池
我们知道，向线程池提交任务是用ThreadPoolExecutor的execute()方法，但在其内部，线程任务的处理其实是相当复杂的，涉及到ThreadPoolExecutor、Worker、Thread三个类的6个方法：
源码解读部分参考链接
3.3.1 execute()
在ThreadPoolExecutor类中，任务提交方法的入口是execute(Runnable command)方法（submit()方法也是调用了execute()），该方法其实只在尝试做一件事：经过各种校验之后，调用 addWorker(Runnable command,boolean core)方法为线程池创建一个线程并执行任务，与之相对应，execute()的结果有两个：
参数说明：
Runnable command：待执行的任务
执行流程：
- 通过
ctl.get()得到线程池的当前线程数，如果线程数小于corePoolSize，则调用addWorker(commond,true)方法创建新的线程执行任务，否则执行步骤2； - 步骤1失败，说明已经无法再创建新线程，那么考虑将任务放入阻塞队列，等待执行完任务的线程来处理。基于此，判断线程池是否处于
Running状态（只有Running状态的线程池可以接受新任务），如果任务添加到任务队列成功则进入步骤3，失败则进入步骤4； - 来到这一步需要说明任务已经加入任务队列，这时要二次校验线程池的状态，会有以下情形：
- 线程池不再是
Running状态了，需要将任务从任务队列中移除，如果移除成功则拒绝本次任务 - 线程池是
Running状态，则判断线程池工作线程是否为0，是则调用addWorker(commond,true)添加一个没有初始任务的线程（这个线程将去获取已经加入任务队列的本次任务并执行），否则进入步骤4； - 线程池不是
Running状态，但从任务队列移除任务失败（可能已被某线程获取？），进入步骤4；
- 线程池不再是
- 将线程池扩容至
maximumPoolSize并调用addWorker(commond,false)方法创建新的线程执行任务，失败则拒绝本次任务。
流程图：
3.3.2 addWorker()
addWorker(Runnable firstTask, boolean core)方法，顾名思义，向线程池添加一个带有任务的工作线程。
参数说明：
Runnable firstTask：新创建的线程应该首先运行的任务（如果没有，则为空）。boolean core：该参数决定了线程池容量的约束条件，即当前线程数量以何值为极限值。参数为true则使用corePollSize作为约束值，否则使用maximumPoolSize。
执行流程：
- 外层循环判断线程池的状态是否可以新增工作线程。这层校验基于下面两个原则：
- 线程池为
Running状态时，既可以接受新任务也可以处理任务 - 线程池为关闭状态时只能新增空任务的工作线程（
worker）处理任务队列（workQueue）中的任务不能接受新任务
- 线程池为
- 内层循环向线程池添加工作线程并返回是否添加成功的结果。
- 首先校验线程数是否已经超限制，是则返回
false，否则进入下一步 - 通过
CAS使工作线程数+1，成功则进入步骤3，失败则再次校验线程池是否是运行状态，是则继续内层循环，不是则返回外层循环
- 首先校验线程数是否已经超限制，是则返回
- 核心线程数量+1成功的后续操作：添加到工作线程集合，并启动工作线程
- 首先获取锁之后，再次校验线程池状态（具体校验规则见代码注解），通过则进入下一步，未通过则添加线程失败
- 线程池状态校验通过后，再检查线程是否已经启动，是则抛出异常，否则尝试将线程加入线程池
检查线程是否启动成功，成功则返回true，失败则进入addWorkerFailed方法
流程图：
3.3.3 Worker类
Worker类是内部类，既实现了Runnable，又继承了AbstractQueuedSynchronizer（以下简称AQS），所以其既是一个可执行的任务，又可以达到锁的效果。
Worker类主要维护正在运行任务的线程的中断控制状态，以及其他次要的记录。这个类适时地继承了AbstractQueuedSynchronizer类，以简化获取和释放锁（该锁作用于每个任务执行代码）的过程。这样可以防止去中断正在运行中的任务，只会中断在等待从任务队列中获取任务的线程。
我们实现了一个简单的不可重入互斥锁，而不是使用可重入锁，因为我们不希望工作任务在调用setCorePoolSize之类的池控制方法时能够重新获取锁。另外，为了在线程真正开始运行任务之前禁止中断，我们将锁状态初始化为负值，并在启动时清除它（在runWorker中）。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
// 通过构造函数初始化，
Worker(Runnable firstTask) {
//设置AQS的同步状态
// state：锁状态，-1为初始值，0为unlock状态，1为lock状态
setState(-1); // inhibit interrupts until runWorker 在调用runWorker前，禁止中断
this.firstTask = firstTask;
// 线程工厂创建一个线程
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this); //runWorker()是ThreadPoolExecutor的方法
}
// Lock methods
// The value 0 represents the unlocked state. 0代表“没被锁定”状态
// The value 1 represents the locked state. 1代表“锁定”状态
protected boolean isHeldExclusively() {
return getState() != 0;
}
/**
* 尝试获取锁的方法
* 重写AQS的tryAcquire()，AQS本来就是让子类来实现的
*/
protected boolean tryAcquire(int unused) {
// 判断原值为0，且重置为1，所以state为-1时，锁无法获取。
// 每次都是0->1，保证了锁的不可重入性
if (compareAndSetState(0, 1)) {
// 设置exclusiveOwnerThread=当前线程
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
/**
* 尝试释放锁
* 不是state-1，而是置为0
*/
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
/**
* 中断（如果运行）
* shutdownNow时会循环对worker线程执行
* 且不需要获取worker锁，即使在worker运行时也可以中断
*/
void interruptIfStarted() {
Thread t;
//如果state>=0、t!=null、且t没有被中断
//new Worker()时state==-1，说明不能中断
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
3.3.4 runWorker()
可以说，runWorker(Worker w)是线程池中真正处理任务的方法，前面的execute()和 addWorker()都是在为该方法做准备和铺垫。
参数说明：
Worker w：封装的Worker，携带了工作线程的诸多要素，包括Runnable（待处理任务）、lock（锁）、completedTasks（记录线程池已完成任务数）
执行流程：
- 判断当前任务或者从任务队列中获取的任务是否不为空，都为空则进入步骤2，否则进入步骤3
- 任务为空，则将
completedAbruptly置为false（即线程不是突然终止），并执行processWorkerExit(w,completedAbruptly)方法进入线程退出程序 - 任务不为空，则进入循环，并加锁
- 判断是否为线程添加中断标识，以下两个条件满足其一则添加中断标识：
- 线程池状态>=
STOP,即STOP或TERMINATED - 一开始判断线程池状态<
STOP，接下来检查发现Thread.interrupted()为true，即线程已经被中断，再次检查线程池状态是否>=STOP（以消除该瞬间shutdown方法生效，使线程池处于STOP或TERMINATED）
- 线程池状态>=
- 执行前置方法
beforeExecute(wt, task)（该方法为空方法，由子类实现）后执行task.run()方法执行任务（执行不成功抛出相应异常） - 执行后置方法
afterExecute(task, thrown)（该方法为空方法，由子类实现）后将线程池已完成的任务数+1，并释放锁。 - 再次进行循环条件判断。
流程图：
3.3.5 getTask()
由函数调用关系图可知，在ThreadPoolExecutor类的实现中，Runnable getTask()方法是为void runWorker(Worker w)方法服务的，它的作用就是在任务队列（workQueue）中获取 task（Runnable）
参数说明：无参数
执行流程：
- 将
timedOut（上次获取任务是否超时）置为false（首次执行方法，无上次，自然为false），进入一个无限循环 - 如果线程池为
Shutdown状态且任务队列为空（线程池shutdown状态可以处理任务队列中的任务，不再接受新任务，这个是重点）或者线程池为STOP或TERMINATED状态，则意味着线程池不必再获取任务了，当前工作线程数量-1并返回null，否则进入步骤3 - 如果线程池数量超限制或者时间超限且（任务队列为空或当前线程数>1），则进入步骤4，否则进入步骤5。
- 移除工作线程，成功则返回null，不成功则进入下轮循环。
- 尝试用
poll() 或者 take()（具体用哪个取决于timed的值）获取任务，如果任务不为空，则返回该任务。如果为空，则将timeOut置为true进入下一轮循环。如果获取任务过程发生异常，则将 timeOut置为 false 后进入下一轮循环。
流程图：
3.3.6 processWorkerExit()
processWorkerExit(Worker w, boolean completedAbruptly)执行线程退出的方法
参数说明：
Worker w：要结束的工作线程。boolean completedAbruptly：是否突然完成（异常导致），如果工作线程因为用户异常死亡，则completedAbruptly参数为true。
执行流程：
- 如果
completedAbruptly 为 true，即工作线程因为异常突然死亡，则执行工作线程-1操作。 - 主线程获取锁后，线程池已经完成的任务数追加 w（当前工作线程） 完成的任务数，并从
worker的set集合中移除当前worker。 - 根据线程池状态进行判断是否执行
tryTerminate()结束线程池。 - 是否需要增加工作线程，如果线程池还没有完全终止，仍需要保持一定数量的线程。
- 如果当前线程是突然终止的，调用
addWorker()创建工作线程 - 当前线程不是突然终止，但当前工作线程数量小于线程池需要维护的线程数量，则创建工作线程。需要维护的线程数量为
corePoolSize（取决于成员变量allowCoreThreadTimeOut是否为false）或1。
- 如果当前线程是突然终止的，调用
4 合理的配置线程池
4.1 线程池分析
要想合理的配置线程池，就必须首先分析任务特性，可以从以下几个角度来进行分析：
任务的性质：CPU密集型任务，IO密集型任务和混合型任务。任务的优先级：高，中和低。任务的执行时间：长，中和短。任务的依赖性：是否依赖其他系统资源，如数据库连接。
任务性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务配置尽可能少的线程数量，如配置Ncpu+1个线程的线程池。IO密集型任务则由于需要等待IO操作，线程并不是一直在执行任务，则配置尽可能多的线程，如2*Ncpu。混合型的任务，如果可以拆分，则将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐率要高于串行执行的吞吐率，如果这两个任务执行时间相差太大，则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。
优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先得到执行，需要注意的是如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。
执行时间不同的任务可以交给不同规模的线程池来处理，或者也可以使用优先级队列，让执行时间短的任务先执行。
依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，如果等待的时间越长CPU空闲时间就越长，那么线程数应该设置越大，这样才能更好的利用CPU。
4.2 有界队列
建议使用有界队列，有界队列能增加系统的稳定性和预警能力，可以根据需要设大一点，比如几千。有一次使用的后台任务线程池的队列和线程池全满了，不断的抛出抛弃任务的异常，通过排查发现是数据库出现了问题，导致执行SQL变得非常缓慢，因为后台任务线程池里的任务全是需要向数据库查询和插入数据的，所以导致线程池里的工作线程全部阻塞住，任务积压在线程池里。如果当时我们设置成无界队列，线程池的队列就会越来越多，有可能会撑满内存，导致整个系统不可用，而不只是后台任务出现问题
5 线程池的监控
5.1 通过线程池提供参数监控
主要说的是自定义线程池，而不是通过ThreadPoolExecutor线程池对象创建
线程池里有一些属性在监控线程池的时候可以使用：
taskCount：线程池需要执行的任务数量。completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCountlargestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。getPoolSize:线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不减。getActiveCount：获取活动的线程数。
5.2 通过扩展线程池进行监控
通过继承线程池并重写线程池的beforeExecute，afterExecute和terminated方法，我们可以在任务执行前，执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如：
protected void beforeExecute(Thread t, Runnable r) { }
附：Spring线程池ThreadPoolTaskExecutor的使用
6 线程组
6.1 线程组定义
可以把线程归属到某一个线程组中，线程组中可以有线程对象，也可以有线程组，组中还可以有线程，这样的组织结构有点类似于树的形式，如图所示.
线程组的作用是：可以批量管理线程或线程组对象，有效地对线程或线程组对象进行组织
相关构造方法：
ThreadGroup(String name):构造一个新线程组ThreadGroup(ThreadGroup parent,String name):构造一个新线程组
注意一下第二个，假如要使用多级关联一般就是用第二个构造函数。第一个参数表示新线程组的父线程组，第二个参数表示新线程组的名称，有了父线程组和新线程组的名称，自然可以构造出一个新的线程组来了。
注意：线程必须启动后才能归到指定线程组中
6.2 使用操作
ThreadGroup其实比ExecutorService更好
用java做抓取的时候免不了要用到多线程的了，因为要同时抓取多个网站或一条线程抓取一个网站的话实在太慢，而且有时一条线程抓取同一个网站的话也比较浪费CPU资源。要用到多线程的等方面，也就免不了对线程的控制或用到线程池
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class JavaThreadPool {
public static void main(String[] args) {
// 创建一个可重用固定线程数的线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
// 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
// 将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
// 关闭线程池
pool.shutdown();
}
}
class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行。。。");
}
}
后来发现ExecutorService的功能没有想像中的那么好，而且最多只是提供一个线程的容器而然，所以后来改用了java.lang.ThreadGroup，ThreadGroup有很多优势，最重要的一点就是它可以对线程进行遍历，知道那些线程已经运行完毕，还有那些线程在运行。关于ThreadGroup的使用代码如下：
class MyThread extends Thread {
boolean stopped;
MyThread(ThreadGroup tg, String name) {
super(tg, name);
stopped = false;
}
public void run() {
System.out.println(Thread.currentThread().getName() + " starting.");
try {
for (int i = 1; i < 1000; i++) {
System.out.print(".");
Thread.sleep(250);
synchronized (this) {
if (stopped)break;
}
}
} catch (Exception exc) {
System.out.println(Thread.currentThread().getName() + " interrupted.");
}
System.out.println(Thread.currentThread().getName() + " exiting.");
}
synchronized void myStop() {
stopped = true;
}
}
public class Main {
public static void main(String args[]) throws Exception {
ThreadGroup tg = new ThreadGroup("My Group");
MyThread thrd = new MyThread(tg, "MyThread #1");
MyThread thrd2 = new MyThread(tg, "MyThread #2");
MyThread thrd3 = new MyThread(tg, "MyThread #3");
thrd.start();
thrd2.start();
thrd3.start();
Thread.sleep(1000);
System.out.println(tg.activeCount() + " threads in thread group.");
Thread thrds[] = new Thread[tg.activeCount()];
tg.enumerate(thrds);
for (Thread t : thrds)
System.out.println(t.getName());
thrd.myStop();
Thread.sleep(1000);
System.out.println(tg.activeCount() + " threads in tg.");
tg.interrupt();
}
}
由以上的代码可以看出：ThreadGroup比ExecutorService多以下几个优势
ThreadGroup可以遍历线程，知道那些线程已经运行完毕，那些还在运行- 可以通过
ThreadGroup.activeCount知道有多少线程从而可以控制插入的线程数
6.3 和线程池区别
线程组和线程池区别：
- 线程组：
线程组存在的意义，首要原因是安全
java默认创建的线程都是属于系统线程组，而同一个线程组的线程是可以相互修改对方的数据的。
但如果在不同的线程组中，那么就不能跨线程组修改数据，可以从一定程度上保证数据安全。 - 线程池：
线程池存在的意义，首要作用是效率
线程的创建和结束都需要耗费一定的系统时间（特别是创建），不停创建和删除线程会浪费大量的时间。所以，在创建出一条线程并使其在执行完任务后不结束，而是使其进入休眠状态，在需要用时再唤醒，那么 就可以节省一定的时间。
如果这样的线程比较多，那么就可以使用线程池来进行管理。保证效率。 - 线程组和线程池共有的特点：
都是管理一定数量的线程
都可以对线程进行控制—包括休眠，唤醒，结束，创建，中断（暂停）–但并不一定包含全部这些操作。
1805
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
