Java ThreadPoolExecutor 线程池调度器

---

可设置的主要参数

全部参数的构造函数：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

corePoolSize

核心线程数。

当线程数小于核心线程数时，即使现有的线程空闲，线程池也会优先创建新线程来处理任务，而不是直接交给现有的线程处理。已创建的核心线程会一直存活，即使没有任务需要处理。

核心线程在allowCoreThreadTimeout被设置为true时会超时退出，默认情况下不会退出。

maximumPoolSize

允许的最大线程数。

该参数排队策略为『无界队列和有界队列』的情况下是无效的。具体见工作队列中的排列策略描述。

keepAliveTime

保持存活的时间值；TimeUnit 给定时间单位。

如果池中当前有多于 corePoolSize 的线程，则这些多出的线程在空闲时间小于keepAliveTime，又来了新的任务时，会复用该线程；反之，当线程空闲时间超过keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。

如果allowCoreThreadTimeout设置为true，则所有线程超出keepAliveTime， 均会退出直到线程数量为0。

• allowCoreThreadTimeout

是否允许核心线程空闲退出，默认值为false。
通过方法 allowsCoreThreadTimeOut(boolean value) 设置。

workQueue

工作队列。类型为 BlockingQueue。

所有 BlockingQueue 都可用于传输和保持提交的任务。

• 如果运行的线程少于 corePoolSize，则创建新的线程，不会将任务入队。
• 如果运行的线程多于 corePoolSize，可能会加入队列，也可能会直接创建新的线程来执行任务；受排队策略的影响。

排队的三种通用策略：

1. 直接提交。工作队列 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交，通常要求无界的 maximumPoolSizes 以避免拒绝新提交的任务，即 maximumPoolSizes=Integer.MAX_VALUE。
   简单来说，直接提交，工作队列不保持任务，无空闲线程时，会新开线程，直到线程数达到 maximumPoolSizes。

SynchronousQueue 的特点是，每个插入操作必须等待另一个线程的对应移除操作。比如，要添加一个元素，接下来如果继续想尝试添加则会阻塞，直到另一个线程取走一个元素，反之亦然
SynchronousQueue 不会保留任务进队列，会直接提交到工作线程。

2. 无界队列，即不限定队列的容量。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求。
   简单来说，无界队列使用未指定容量的 BlockingQueue (它是一个接口，可自行查看下它的家谱)，线程数不超过corePoolSize，多余任务在队列中等待。maximumPoolSize无效。

3. 有界队列，即限定队列的容量。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue或具有预定义容量的 LinkedBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。
   简单来说，限定了队列的边界，并使用有限的maximumPoolSizes；会创建新的线程(即工作中的线程未达到maximumPoolSizes，又有新的任务进来时)；线程达到maximumPoolSizes时，新任务入队；在队列饱和且线程数达到maximumPoolSizes时，新的任务将被拒绝，受RejectedExecutionHandler影响。

ThreadFactory

线程工厂，用于创建新的线程。该接口只有一个抽象方法：

Thread newThread(Runnable r);

RejectedExecutionHandler

public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

任务拒绝处理策略。
当 线程池 关闭时，会触发该策略。
或者 使用有限边界和有限的 maximumPoolSizes，且已经饱和时，会触发该策略。

在源码中定义了如下几种策略：

AbortPolicy (默认策略)

```java
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());
        }
    }
```

该策略 直接抛出了异常。异常中止

CallerRunsPolicy

```java
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}
```

直接在当前线程执行任务。所谓当前线程，即提交任务时的线程，即调用 ThreadPoolExecutor#execute()的线程。

DiscardPolicy

```java
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}
```

丢弃新任务。不做任何处理，跳过任务r

DiscardOldestPolicy

```java
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}
```

在线程池未关闭时，移除处于队头的任务，再执行任务r。相当于把之前队头的任务跳过了，把r又加入了队列

---

Executors生成ThreadPoolExecutor

生成一个固定线程数的ThreadPoolExecutor

public static ExecutorService newFixedThreadPool(int nThreads) {

​    return new ThreadPoolExecutor(nThreads, nThreads,
​                                  0L, TimeUnit.MILLISECONDS,
​                                  new LinkedBlockingQueue<Runnable>());

}

无界队列实现，线程数不会超过第一个参数 nThreads； 第二个参数 nThreads失效。线程保活时间0。

LinkedBlockingQueue实现是线程安全的，实现了先进先出等特性，是作为生产者消费者的首选，LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的话，默认最大是Integer.MAX_VALUE

生成一个只含一个线程的ThreadPoolExecutor

public static ExecutorService newSingleThreadExecutor() {

​ return new FinalizableDelegatedExecutorService

​ (new ThreadPoolExecutor(1, 1,

​ 0L, TimeUnit.MILLISECONDS,

​ new LinkedBlockingQueue()));

}
无界队列实现，线程数不会超过第一个参数 1； 第二个参数 1失效。线程保活时间0。

生成一个线程缓存的ThreadPoolExecutor

public static ExecutorService newCachedThreadPool() {

​ return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

​ 60L, TimeUnit.SECONDS,

​ new SynchronousQueue());

}
直接提交，按需创建新线程。线程保活时间60秒。

---

线程池的关闭

两个方法 shutdownNow() 和 shutdown();

shutdownNow()

内部会立即试图调用 线程 Thread#interrupt()，来打断线程。
若线程中有 Thread.sleep() 或 Object#wait() 阻塞了线程，会造成异常；所以线程内部运行的代码最好加上try-catch代码块。

shutdown()

等待线程内部任务执行完毕，再关闭线程池。
即使线程中有 Thread.sleep() 或 Object#wait() 阻塞了线程，也不会造成异常；但最好对线程内部运行的代码加上try-catch代码块，因为可能是其它方面发生了异常。

通常在程序中，仅在退出程序前，调用关闭线程池的操作。

---

常用函数

isShutdown() isTerminated()

isShutdown() 在 线程池已关闭后，即调用shutdown()/shutdownNow()，会返回true。
isTerminated() 在 线程池已关闭后，即调用shutdown()/shutdownNow()，会返回true 或者 false；取决于池内的所有任务是否都已关闭。

getActiveCount()

返回主动执行任务的近似线程数。
因为在计算期间任务和线程的状态可能动态改变，所以返回值只是一个近似值。

getTaskCount()

返回曾计划执行的近似任务总数。

getCompletedTaskCount()

返回已完成执行的近似任务总数。

awaitTermination(long timeout, TimeUnit unit)

等待终止。给一个超时时间。超时时间前终止，返回true；终止前超时期满，则返回 false。需要与shutdown()/shutdownNow() 配合使用。

---

测试

  private ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10,
            30L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(10), 
            new ThreadPoolExecutor.DiscardOldestPolicy());

测试时，使用不同的 队列，不同的 maximumPoolSize，不同的 RejectedExecutionHandler来测试。

---