线程池ThreadPoolExecutor
线程池ThreadPoolExecutor
1、线程池介绍
1.1 线程池概念
Sun在Java5中，对Java线程的类库做了大量的扩展，其中线程池就是Java5的新特征之一，除了线程池之外，还有很多多线程相关的内容，为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序，线程部分的新增内容显得尤为重要。
有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类。
线程池的基本思想是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。
1.2 线程池好处
合理利用线程池能够带来三个好处
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。
2、线程池的使用
2.1 线程池的创建
2.1.1 通过ThreadPoolExecutor创建
可以通过ThreadPoolExecutor来创建一个线程池
new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
创建一个线程池需要输入几个参数：
- corePoolSize（核心池的大小）：在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这两个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；当提交任务后，正在运行的线程少于 corePoolSize 时，即使其他工作线程处于空闲状态，也会创建一个新线程来处理该请求。
- maximumPoolSize（线程池最大大小）：线程池允许创建的最大线程数。它表示在线程池中最多能创建多少个线程；如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列（长度无穷大）这个参数就没什么效果。
- keepAliveTime（线程活动保持时间）：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；当线程池中的线程数大于核心线程数corePoolSize时，空闲线程的最大存活时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。
- TimeUnit（线程活动保持时间的单位）：参数keepAliveTime的时间单位；可选的单位有天（DAYS），小时（HOURS），分钟（MINUTES），毫秒(MILLISECONDS)，微秒(MICROSECONDS, 千分之一毫秒)和毫微秒(NANOSECONDS, 千分之一微秒)
- runnableTaskQueue（任务队列）：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响；可以选择以下几个阻塞队列：
- ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。
- LinkedBlockingQueue：一个基于链表结构的有界阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。可以指定阻塞队列的容量，当未指定时使用Integer.MAX_VALUE。静态工厂方法Executors.newFixedThreadPool()和newSingleThreadExecutor使用了这个队列。
- SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
- PriorityBlockingQueue：一个具有优先级得无限阻塞队列。
- DelayedWorkQueue：一个使用优先级队列实现的无界阻塞队列，静态工厂方法Executors.newScheduledThreadPool使用
- ThreadFactory：创建线程的工厂，主要用来创建线程；可以通过线程工厂给每个创建出来的线程设置更有意义的名字，Debug和定位问题时非常有帮助。
- RejectedExecutionHandler（拒绝策略）：当队列和线程池线程数maximumPoolSize都达到最大值时，说明线程池处于饱和状态，必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略：
- AbortPolicy：丢弃新来无法处理的任务并抛出RejectedExecutionException异常。
- DiscardPolicy：丢弃新来无法处理的任务，但不抛出异常。
- DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行新来的任务（重复此过程）。
- CallerRunsPolicy：由调用线程处理该任务。
- 自定义策略：当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。
任务交给线程池后的执行流程
当任务提交给ThreadPoolExecutor线程池中，先检查核心线程数corePoolSize是否已经全部使用，如果没有，则创建新的核心线程去执行任务，
如果核心线程数corePoolSize已经全部占用，则将任务添加到队列里面，
如果队列已经占满，比较当前线程池中的线程的数量是不是已超过maximumPoolSize，
如果当前线程数没有超过maximumPoolSize则创建线程去执行，
也就是说线程池最多可以接受多少任务呢？就是maximumPoolSize+队列的大小。
如果当前线程数超过maximumPoolSize，再来新任务需要处理时，则启动拒绝策略。
当线程池中的线程的数量大于corePoolSize数量时，有空闲线程则执行回收，回收时间是keepAliveTime，单位是unit，都是初始化的时候设置的。
2.1.2 通过Executors方式创建
Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：
newCachedThreadPool: 创建一个可缓存线程池，如果线程池大小超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程newFixedThreadPool: 创建一个线程容量固定的线程池，可控制线程最大并发数，超出的线程会在队列中等待newScheduledThreadPool: 创建一个核心线程数固定的线程池，支持定时及周期性任务执行newSingleThreadExecutor: 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
2.2 线程池提交的返回值
2.2.1 无返回值
2.2.1.1 execute提交
可使用execute提交任务，但execute方法没有返回值，所以无法判断任务是否被线程池执行成功。通过以下代码可知execute方法输入的任务是一个Runnable类的实例
threadPool.execute(new Runnable() { @Override public void run() { // TODO execute task } });
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
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.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: Accept new tasks and process queued tasks * SHUTDOWN: Don't accept new tasks, but process queued tasks * STOP: Don't accept new tasks, don't process queued tasks, * and interrupt in-progress tasks * TIDYING: All tasks have terminated, workerCount is zero, * the thread transitioning to state TIDYING * will run the terminated() hook method * TERMINATED: terminated() has completed
* RUNNING -> SHUTDOWN
* On invocation of shutdown(), perhaps implicitly in finalize()
* (RUNNING or SHUTDOWN) -> STOP
* On invocation of shutdownNow()
* SHUTDOWN -> TIDYING
* When both queue and pool are empty
* STOP -> TIDYING
* When pool is empty
* TIDYING -> TERMINATED
* When the terminated() hook method has completed
*
* Threads waiting in awaitTermination() will return when the
* state reaches TERMINATED.
1）RUNNING
该状态的线程池会接收新任务，并处理阻塞队列中的任务；
调用线程池的shutdown()方法，可以切换到SHUTDOWN状态；
调用线程池的shutdownNow()方法，可以切换到STOP状态；
2）SHUTDOWN
该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
队列为空，并且线程池中执行的任务也为空,进入TIDYING状态；
3）STOP
该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
线程池中执行的任务为空，进入TIDYING状态；
4）TIDYING
该状态表明所有的任务已经运行终止，记录的任务数量为0
terminated()执行完毕，进入TERMINATED状态
5）TERMINATED
该状态表示线程池彻底终止
3、线程池的分析
3.1 流程分析
Java线程池主要工作流程：
当提交一个新任务到线程池时，线程池的处理流程如下：
首先线程池判断核心线程数corePoolSize是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。
其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。
最后线程池判断线程池的最大线程数maximumPoolSize是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给拒绝策略来处理这个任务。
另外：当线程池中线程数大于corePoolSize数，空闲线程空闲时间达到keepAliveTime时，关闭空闲线程。
当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭。
线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。
可以从Worker的run方法里看到这点：
public void runWorker() { try { Runnable task = firstTask; firstTask = null; while (task != null || (task = getTask()) != null) { runTask(task); task = null; } } finally { workerDone(this); } }
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：线程池在运行过程中已完成的任务数量。小于或等于taskCount
- largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。
- getPoolSize：线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不减。
- getActiveCount：获取活动的线程数。
5.2 通过扩展线程池进行监控
通过继承线程池并重写线程池的beforeExecute，afterExecute和terminated方法，可以在任务执行前，执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如：
protected void beforeExecute(Thread t, Runnable r) { }
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默认创建的线程都是属于系统线程组，而同一个线程组的线程是可以相互修改对方的数据。
但如果在不同的线程组中，那么就不能跨线程组修改数据，可以从一定程度上保证数据安全。
线程池：
线程池存在的意义，首要作用是效率
线程的创建和结束都需要耗费一定的系统时间（特别是创建），不停创建和删除线程会浪费大量的时间。所以，在创建出一条线程并使其在执行完任务后不结束，而是使其进入休眠状态，在需要用时再唤醒，那么 就可以节省一定的时间。
如果这样的线程比较多，那么就可以使用线程池来进行管理。保证效率。
线程组和线程池共有的特点：
都是管理一定数量的线程
都可以对线程进行控制—包括休眠，唤醒，结束，创建，中断（暂停）–但并不一定包含全部这些操作。
