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：一个基于链表结构的 有界/(无界：未指定容量则Integer.MAX_VALUE)阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()和newSingleThreadExecutor使用了这个队列，注意：如果不指定队列大小，就默认为Integer.MAX_VALUE。
  • SynchronousQueue：一个无容量的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
  • PriorityBlockingQueue：一个具有优先级的无限阻塞队列。存放在PriorityBlockingQueue中的元素必须实现Comparable接口，这样才能通过实现compareTo()方法进行排序。优先级最高的元素将始终排在队列的头部；PriorityBlockingQueue不会保证优先级一样的元素的排序，也不保证当前队列中除了优先级最高的元素以外的元素，随时处于正确排序的位置。
  • DelayedWorkQueue:一个使用优先级队列实现的无界阻塞队列，静态工厂方法Executors.newScheduledThreadPool使用。
    基于二叉堆实现，同时具备：无界队列、阻塞队列、优先队列的特征。DelayQueue延迟队列中存放的对象，必须是实现Delayed接口的类对象。通过执行时延从队列中提取任务，时间没到任务取不出来。
  • LinkedBlockingDeque： 双端队列， 有界/(无界：未指定容量则Integer.MAX_VALUE)阻塞队列，基于链表实现，既可以从尾部插入/取出元素，还可以从头部插入元素/取出元素。
  • 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() + "正在执行。。。"); 
        } 
}

• 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 异常抛出

execute：提交的任务在Worker#run中被捕获后直接抛出。
submit：提交的任务在FutureTask#run中被捕获后存储到了属性outcome，get 时才会抛出异常。

为什么submit提交的任务要get时才会获取结果？

Callable提交的任务，我们只需要关心其结果即可，不用关心其过程，主线程只需要在处理完自己的任务后获取一个或一批任务的状态和结果，让开发者决定何时检查任务是否成功完成，以及如何处理异常。
而Runnable我们一般不要获取返回值，只需要提交任务即可，如果不直接抛出异常就会导致任务失败了但是没有感知，尤其是在任务中catch遗漏的一些没有预料到异常且未设置UncaughtExceptionHandler的时候。
虽然 Runnable 任务虽然没有返回值，但也可以submit, 然后通过 Future.get() 了解到其成功或失败的状态。

2.2.5 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;

线程池各个状态切换状态图如下：

image.png

• RUNNING
  当创建线程池后，初始时，线程池处于RUNNING状态
  该状态的线程池会接收新任务，并处理阻塞队列中的任务;
  调用线程池的shutdown()方法，可以切换到SHUTDOWN状态;
  调用线程池的shutdownNow()方法，可以切换到STOP状态;
• SHUTDOWN
  该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
  队列为空，并且线程池中执行的任务也为空,进入TIDYING状态;
• STOP
  该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
  线程池中执行的任务为空,进入TIDYING状态;
• TIDYING
  该状态表明所有的任务已经运行终止，记录的任务数量为0。
  terminated()执行完毕，进入TERMINATED状态
• TERMINATED
  该状态表示线程池彻底终止

3 线程池的分析

3.1 流程分析

Java线程池主要工作流程：

image.png

工作流程模型图参考链接

当提交一个新任务到线程池时，线程池的处理流程如下：

• 首先线程池判断基本线程池是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。
• 其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。
• 最后线程池判断整个线程池是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务。

另外：当线程池中超过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个方法：

image.png

源码解读部分参考链接

3.3.1 execute()

在ThreadPoolExecutor类中，任务提交方法的入口是execute(Runnable command)方法（submit()方法也是调用了execute()），该方法其实只在尝试做一件事：经过各种校验之后，调用 addWorker(Runnable command,boolean core)方法为线程池创建一个线程并执行任务，与之相对应，execute()的结果有两个：

参数说明：

• Runnable command：待执行的任务

执行流程：

1. 通过 ctl.get() 得到线程池的当前线程数，如果线程数小于corePoolSize，则调用 addWorker(commond,true) 方法创建新的线程执行任务，否则执行步骤2；
2. 步骤1失败，说明已经无法再创建新线程，那么考虑将任务放入阻塞队列，等待执行完任务的线程来处理。基于此，判断线程池是否处于Running状态（只有Running状态的线程池可以接受新任务），如果任务添加到任务队列成功则进入步骤3，失败则进入步骤4；
3. 来到这一步需要说明任务已经加入任务队列，这时要二次校验线程池的状态，会有以下情形：
   • 线程池不再是Running状态了，需要将任务从任务队列中移除，如果移除成功则拒绝本次任务
   • 线程池是Running状态，则判断线程池工作线程是否为0，是则调用 addWorker(commond,true)添加一个没有初始任务的线程（这个线程将去获取已经加入任务队列的本次任务并执行），否则进入步骤4；
   • 线程池不是Running状态，但从任务队列移除任务失败（可能已被某线程获取？），进入步骤4；
4. 将线程池扩容至maximumPoolSize并调用 addWorker(commond,false) 方法创建新的线程执行任务，失败则拒绝本次任务。

流程图：

image.png

3.3.2 addWorker()

addWorker(Runnable firstTask, boolean core)方法，顾名思义，向线程池添加一个带有任务的工作线程。

参数说明：

• Runnable firstTask：新创建的线程应该首先运行的任务（如果没有，则为空）。
• boolean core：该参数决定了线程池容量的约束条件，即当前线程数量以何值为极限值。参数为 true 则使用corePollSize 作为约束值，否则使用maximumPoolSize。

执行流程：

1. 外层循环判断线程池的状态是否可以新增工作线程。这层校验基于下面两个原则：
   • 线程池为Running状态时，既可以接受新任务也可以处理任务
   • 线程池为关闭状态时只能新增空任务的工作线程（worker）处理任务队列（workQueue）中的任务不能接受新任务
2. 内层循环向线程池添加工作线程并返回是否添加成功的结果。
   • 首先校验线程数是否已经超限制，是则返回false，否则进入下一步
   • 通过CAS使工作线程数+1，成功则进入步骤3，失败则再次校验线程池是否是运行状态，是则继续内层循环，不是则返回外层循环
3. 核心线程数量+1成功的后续操作：添加到工作线程集合，并启动工作线程
   • 首先获取锁之后，再次校验线程池状态（具体校验规则见代码注解），通过则进入下一步，未通过则添加线程失败
   • 线程池状态校验通过后，再检查线程是否已经启动，是则抛出异常，否则尝试将线程加入线程池
     检查线程是否启动成功，成功则返回true，失败则进入 addWorkerFailed 方法

流程图：

image.png

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（记录线程池已完成任务数）

执行流程：

1. 判断当前任务或者从任务队列中获取的任务是否不为空，都为空则进入步骤2，否则进入步骤3
2. 任务为空，则将completedAbruptly置为false（即线程不是突然终止），并执行processWorkerExit(w,completedAbruptly)方法进入线程退出程序
3. 任务不为空，则进入循环，并加锁
4. 判断是否为线程添加中断标识，以下两个条件满足其一则添加中断标识：
   • 线程池状态>=STOP,即STOP或TERMINATED
   • 一开始判断线程池状态<STOP，接下来检查发现Thread.interrupted()为true，即线程已经被中断，再次检查线程池状态是否>=STOP（以消除该瞬间shutdown方法生效，使线程池处于STOP或TERMINATED）
5. 执行前置方法 beforeExecute(wt, task)（该方法为空方法，由子类实现）后执行task.run()方法执行任务（执行不成功抛出相应异常）
6. 执行后置方法 afterExecute(task, thrown)（该方法为空方法，由子类实现）后将线程池已完成的任务数+1，并释放锁。
7. 再次进行循环条件判断。

流程图：

image.png

3.3.5 getTask()

由函数调用关系图可知，在ThreadPoolExecutor类的实现中，Runnable getTask()方法是为void runWorker(Worker w)方法服务的，它的作用就是在任务队列（workQueue）中获取 task（Runnable）

参数说明：无参数

执行流程：

1. 将timedOut（上次获取任务是否超时）置为false（首次执行方法，无上次，自然为false），进入一个无限循环
2. 如果线程池为Shutdown状态且任务队列为空（线程池shutdown状态可以处理任务队列中的任务，不再接受新任务，这个是重点）或者线程池为STOP或TERMINATED状态，则意味着线程池不必再获取任务了，当前工作线程数量-1并返回null，否则进入步骤3
3. 如果线程池数量超限制或者时间超限且（任务队列为空或当前线程数>1），则进入步骤4，否则进入步骤5。
4. 移除工作线程，成功则返回null，不成功则进入下轮循环。
5. 尝试用poll() 或者 take()（具体用哪个取决于timed的值）获取任务，如果任务不为空，则返回该任务。如果为空，则将timeOut 置为 true进入下一轮循环。如果获取任务过程发生异常，则将 timeOut置为 false 后进入下一轮循环。

流程图：

image.png

3.3.6 processWorkerExit()

processWorkerExit(Worker w, boolean completedAbruptly)执行线程退出的方法

参数说明：

• Worker w：要结束的工作线程。
• boolean completedAbruptly：是否突然完成（异常导致），如果工作线程因为用户异常死亡，则completedAbruptly参数为 true。

执行流程：

1. 如果 completedAbruptly 为 true，即工作线程因为异常突然死亡，则执行工作线程-1操作。
2. 主线程获取锁后，线程池已经完成的任务数追加 w（当前工作线程） 完成的任务数，并从worker的set集合中移除当前worker。
3. 根据线程池状态进行判断是否执行tryTerminate()结束线程池。
4. 是否需要增加工作线程，如果线程池还没有完全终止，仍需要保持一定数量的线程。
   • 如果当前线程是突然终止的，调用addWorker()创建工作线程
   • 当前线程不是突然终止，但当前工作线程数量小于线程池需要维护的线程数量，则创建工作线程。需要维护的线程数量为corePoolSize（取决于成员变量 allowCoreThreadTimeOut是否为 false）或1。

3.4 线程池的线程回收--回收的是非核心线程吗

一个线程池，如下：

ExecutorService executorService =
                    ThreadPoolExecutor(
                        2,
                        3,
                        60_000,
                        TimeUnit.MILLISECONDS,
                        LinkedBlockingQueue(2),
                        ZjtThreadFactory()
                    )

即核心池的大小是2，最大线程数是3，等待队列的大小是2，非核心线程存活的时间是60秒。

假设现在向线程池中提交5个任务，每个任务耗时1s，那么按照线程池的原理，肯定是先创建2个线程（线程1和线程2）分别执行任务1和任务2，然后任务3和任务4放到等待队列中，然后再创建一个线程执行任务5，等1s任务结束后，线程1和线程2去等待队列中去取任务3和任务4执行。再然后就是任务执行完了，线程1和线程2和线程3都在等待任务，等待60秒之后会回收线程3。

注意本例中是回收线程3，并不是因为线程3是非核心线程，而是线程1和线程2执行完任务1和任务2后又去队列中取任务3和任务4执行了，线程3最先等待，所以会先回收线程3。

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 通过线程池提供参数监控

线程池里有一些属性在监控线程池的时候可以使用：

• taskCount：线程池需要执行的任务数量。
• completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount
• largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。
• 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多以下几个优势

1. ThreadGroup可以遍历线程，知道那些线程已经运行完毕，那些还在运行
2. 可以通过ThreadGroup.activeCount知道有多少线程从而可以控制插入的线程数

6.3 和线程池区别

线程组和线程池区别：

• 线程组：
  线程组存在的意义，首要原因是安全
java默认创建的线程都是属于系统线程组，而同一个线程组的线程是可以相互修改对方的数据的。
  但如果在不同的线程组中，那么就不能跨线程组修改数据，可以从一定程度上保证数据安全。
• 线程池：
  线程池存在的意义，首要作用是效率
  线程的创建和结束都需要耗费一定的系统时间（特别是创建），不停创建和删除线程会浪费大量的时间。所以，在创建出一条线程并使其在执行完任务后不结束，而是使其进入休眠状态，在需要用时再唤醒，那么 就可以节省一定的时间。
  如果这样的线程比较多，那么就可以使用线程池来进行管理。保证效率。
• 线程组和线程池共有的特点：
  都是管理一定数量的线程
  都可以对线程进行控制---包括休眠，唤醒，结束，创建，中断（暂停）--但并不一定包含全部这些操作。