java多线程(15)--线程池ThreadPoolExecutor使用

1. ThreadPoolExecutor的一个常用的构造方法

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

参数说明：

-corePoolSize 　　 　　 线程池中所保存的核心线程数。线程池启动后默认是空的，只有任务来临时才会创建线程以处理请求。prestartAllCoreThreads方法可以在线程池启动后即启动所有核心线程以等待任务。

-maximumPoolSize　　线程池允许创建的最大线程数。当workQueue使用无界队列时（如：LinkedBlockingQueue），则此参数无效。

-keepAliveTime 　　　  当前线程池线程总数大于核心线程数时，终止多余的空闲线程的时间。

-unit　　　　　　　　　 keepAliveTime参数的时间单位。

-workQueue 　　　　　 工作队列，如果当前线程池达到核心线程数时（corePoolSize），且当前所有线程都处于活动状态，则将新加入的任务放到此队列中。下面仅列几个常用的：

• ArrayBlockingQueue：　　基于数组结构的有界队列，此队列按FIFO原则对任务进行排序。如果队列满了还有任务进来，则调用拒绝策略。
• LinkedBlockingQueue：　 基于链表结构的无界队列，此队列按FIFO原则对任务进行排序。因为它是无界的，根本不会满，所以采用此队列后线程池将忽略拒绝策略（handler）参数；同时还将忽略最大线程数（maximumPoolSize）等参数。
• SynchronousQueue：　　 直接将任务提交给线程而不是将它加入到队列，实际上此队列是空的。每个插入的操作必须等到另一个调用移除的操作；如果新任务来了线程池没有任何可用线程处理的话，则调用拒绝策略。其实要是把maximumPoolSize设置成无界（Integer.MAX_VALUE）的，加上SynchronousQueue队列，就等同于Executors.newCachedThreadPool()。
• PriorityBlockingQueue：　具有优先级的队列的有界队列，可以自定义优先级；默认是按自然排序，可能很多场合并不合适。

-handler　　　　　　    拒绝策略，当线程池与workQueue队列都满了的情况下，对新加任务采取的策略。

• AbortPolicy：　　         拒绝任务，抛出RejectedExecutionException异常。默认值。
• CallerRunsPolicy：　　重试添加当前的任务，他会自动重复调用execute()方法
  
• DiscardOldestPolicy：  如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。这样的结果是最后加入的任务反而有可能被执行到，先前加入的都被抛弃了。--抛弃旧的任务
  
• DiscardPolicy：　　　   加不进的任务都被抛弃了，同时没有异常抛出。--抛弃当前的任务

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：

NANOSECONDS、

MICROSECONDS、

MILLISECONDS、

SECONDS。

2. 详解及示范

1. 一个任务进来（Runnable）时，如果核心线程数（corePoolSize）未达到，则直接创建线程处理该任务；如果核心线程数已经达到则该任务进入工作队列（workQueue）。如果工作队列满了（只能是有界队列），则检查最大线程数（maximumPoolSize）是否达到，如果没达到则创建线程处理任务（FIFO）；如果最大线程数据也达到了，则调用拒绝策略（handler）。
2. 如果workQueue使用LinkedBlockingQueue队列，因为它是无界的，队列永远不会满，所以maximumPoolSize参数是没有意义的，同样keepAliveTime、unit、handler三个参数都无意义。
3. 如果workQueue使用ArrayBlockingQueue队列，那么小心，因为此队列是有界的，必须小心处理拒绝策略。

排队有三种通用策略：

直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集合时出现锁定。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙的情况下将新任务加入队列。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

被拒绝的任务

 

当 Executor 已经关闭，并且 Executor 将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法execute(java.lang.Runnable) 中提交的新任务将被拒绝。在以上两种情况下，execute 方法都将调用其RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：

A.        在默认的 ThreadPoolExecutor.AbortPolicy 中，处理程序遭到拒绝将抛出运行时 RejectedExecutionException。

B.        在 ThreadPoolExecutor.CallerRunsPolicy 中，线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。

C.        在 ThreadPoolExecutor.DiscardPolicy 中，不能执行的任务将被删除。

D.        在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

定义和使用其他种类的 RejectedExecutionHandler 类也是可能的，但这样做需要非常小心，尤其是当策略仅用于特定容量或排队策略时。

package com.clzhang.sample.thread;import java.util.concurrent.BlockingQueue;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.PriorityBlockingQueue;import java.util.concurrent.SynchronousQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class ThreadPoolTest3 {    static class MyThread implements Runnable {        private String name;        public MyThread(String name) {            this.name = name;        }        @Override        public void run() {            // 做点事情            try {                Thread.sleep(1000);                                    System.out.println(name + " finished job!") ;            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    public static void main(String[] args) {        // 创建线程池，为了更好的明白运行流程，增加了一些额外的代码//        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(2);        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();//        BlockingQueue<Runnable> queue = new PriorityBlockingQueue<Runnable>();//        BlockingQueue<Runnable> queue = new SynchronousQueue<Runnable>();                // AbortPolicy/CallerRunsPolicy/DiscardOldestPolicy/DiscardPolicy        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 5, TimeUnit.SECONDS,                queue, new ThreadPoolExecutor.AbortPolicy());        // 向线程池里面扔任务        for (int i = 0; i < 10; i++) {            System.out.println("当前线程池大小[" + threadPool.getPoolSize() + "],当前队列大小[" + queue.size() + "]");            threadPool.execute(new MyThread("Thread" + i));        }        // 关闭线程池        threadPool.shutdown();    }}

输出(采用LinkedBlockingQueue队列)：

当前线程池大小[0],当前队列大小[0]
当前线程池大小[1],当前队列大小[0]
当前线程池大小[2],当前队列大小[0]
当前线程池大小[2],当前队列大小[1]
当前线程池大小[2],当前队列大小[2]
当前线程池大小[2],当前队列大小[3]
当前线程池大小[2],当前队列大小[4]
当前线程池大小[2],当前队列大小[5]
当前线程池大小[2],当前队列大小[6]
当前线程池大小[2],当前队列大小[7]
Thread1 finished job!
Thread0 finished job!
Thread3 finished job!
Thread2 finished job!
Thread4 finished job!
Thread5 finished job!
Thread6 finished job!
Thread7 finished job!
Thread8 finished job!
Thread9 finished job!

二、线程的创建与销毁

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通过优先级安排任务