Java 7之多线程线程池 - 线程池原理（1）

来看一下线程池的框架图，如下：

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 InterruptedException;    // 省略部分方法}

3、ThreadPoolExecutor线程池实现类

先来看一下这个类中定义的重要变量，如下：

private final BlockingQueue<Runnable> workQueue;              // 阻塞队列private final ReentrantLock mainLock = new ReentrantLock();   // 互斥锁private final HashSet<Worker> workers = new HashSet<Worker>();// 线程集合.一个Worker对应一个线程private final Condition termination = mainLock.newCondition();// 终止条件private int largestPoolSize;           // 线程池中线程数量曾经达到过的最大值。private long completedTaskCount;       // 已完成任务数量private volatile ThreadFactory threadFactory;     // ThreadFactory对象，用于创建线程。private volatile RejectedExecutionHandler handler;// 拒绝策略的处理句柄private volatile long keepAliveTime;   // 线程池维护线程所允许的空闲时间private volatile boolean allowCoreThreadTimeOut;private volatile int corePoolSize;     // 线程池维护线程的最小数量，哪怕是空闲的private volatile int maximumPoolSize;  // 线程池维护的最大线程数量

其中有几个重要的规则需要说明一下：

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

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 ThreadGroup group;    private final AtomicInteger threadNumber = new AtomicInteger(1);    private final String namePrefix;    DefaultThreadFactory() {        SecurityManager s = System.getSecurityManager();        group = (s != null) ? s.getThreadGroup() :  Thread.currentThread().getThreadGroup();        namePrefix = "pool-" +  poolNumber.getAndIncrement() +  "-thread-";    }    // 为线程池创建新的任务执行线程    public Thread newThread(Runnable r) {        // 线程对应的任务是Runnable对象r        Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);        // 设为非守护线程        if (t.isDaemon())            t.setDaemon(false);        // 将优先级设为Thread.NORM_PRIORITY        if (t.getPriority() != Thread.NORM_PRIORITY)            t.setPriority(Thread.NORM_PRIORITY);        return t;    }}

4>RejectedExecutionHandler

    当Executor已经关闭（即执行了executorService.shutdown()方法后），并且Executor将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法execute()中提交的新任务将被拒绝.

　 在以上述情况下，execute 方法将调用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：

　　　　1) 在默认的 ThreadPoolExecutor.AbortPolicy      处理程序遭到拒绝将抛出运行时 RejectedExecutionException;
　　　　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 {    private String name;    public MyRunnable(String name) {        this.name = name;    }    @Override    public void run() {        try {            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 {        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY));        // 设置线程池的拒绝策略为"丢弃"        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());        // 新建10个任务，并将它们添加到线程池中。        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是一个有界的阻塞队列，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 {        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,                new ArrayBlockingQueue<Runnable>(CAPACITY));        // 设置线程池的拒绝策略为"DiscardOldestPolicy"        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());        // 新建10个任务，并将它们添加到线程池中。        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 {        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,                new ArrayBlockingQueue<Runnable>(CAPACITY));        // 设置线程池的拒绝策略为"抛出异常"        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());        try {            // 新建10个任务，并将它们添加到线程池中。            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 {        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,                new ArrayBlockingQueue<Runnable>(CAPACITY));        // 设置线程池的拒绝策略为"CallerRunsPolicy"        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());        // 新建10个任务，并将它们添加到线程池中。        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之后，当有任务添加到线程池被拒绝时，线程池会将被拒绝的任务添加到"线程池正在运行的线程"中取运行。