Java并发编程——线程池

使用原因

创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变 长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候 就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。从 JDK1.5 开始，Java API 提供了 Executor 框架让你可以创建不同的线程池。

Executor框架

Executor框架包括3大部分：

• 任务。也就是工作单元，包括被执行任务需要实现的接口：Runnable接口或者Callable接口；
• 任务的执行。也就是把任务分派给多个线程的执行机制，包括Executor接口及继承自Executor接口的ExecutorService接口。
• 异步计算的结果。包括Future接口及实现了Future接口的FutureTask类。
  

ThreadPoolExecutor

最全的构造方法

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

参数	说明
corePoolSize	核心线程数目 (多保留的线程数)
maximumPoolSize	最大线程数目
keepAliveTime	当前线程池数量超过corePoolSize时，多余的空闲线程的存活时间，即多 次时间内会被销毁
unit	时间单位
workQueue	阻塞队列
threadFactory	线程工厂
handler	拒绝策略

工作原理

• 线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面 有任务，线程池也不会马上执行它们。
• 当调用 execute() 方法添加一个任务时，线程池会做如下判断：
  a) 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
  b) 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
  c) 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务
  d) 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池根据拒绝策略处理
• 当一个线程完成任务时，它会从队列中取下一个任务来执行。
• 当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运 行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它 最终会收缩到 corePoolSize 的大小
  

线程池状态

ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量

阻塞队列

• ArrayBlockingQueue（公平、非公平）
  用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。默认情况下 不保证访问者公平的访问队列，所谓公平访问队列是指阻塞的所有生产者线程或消费者线程，当 队列可用时，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入 元素，先阻塞的消费者线程，可以先从队列里获取元素。通常情况下为了保证公平性会降低吞吐 量。我们可以使用以下代码创建一个公平的阻塞队列：

  ArrayBlockingQueue fairQueue = new  ArrayBlockingQueue(1000,true); 
  

• LinkedBlockingQueue（两个独立锁提高并发）
  基于链表的阻塞队列，同ArrayListBlockingQueue类似，此队列按照先进先出（FIFO）的原则对 元素进行排序。而 LinkedBlockingQueue 之所以能够高效的处理并发数据，还因为其对于生产者 端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费 者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。
  LinkedBlockingQueue会默认一个类似无限大小的容量（Integer.MAX_VALUE）。

• PriorityBlockingQueue（compareTo排序实现优先）
  是一个支持优先级的无界队列。默认情况下元素采取自然顺序升序排列。可以自定义实现 compareTo()方法来指定元素进行排序规则，或者初始化 PriorityBlockingQueue 时，指定构造 参数Comparator来对元素进行排序。需要注意的是不能保证同优先级元素的顺序。

• DelayQueue（缓存失效、定时任务 ）
  是一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue来实现。队列中的元素必须实 现 Delayed 接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才 能从队列中提取元素。我们可以将DelayQueue运用在以下应用场景：

  1. 缓存系统的设计：可以用 DelayQueue 保存缓存元素的有效期，使用一个线程循环查询 DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。
  2. 定时任务调度：使用 DelayQueue 保存当天将会执行的任务和执行时间，一旦从 DelayQueue 中获取到任务就开始执行，从比如 TimerQueue 就是使用 DelayQueue 实现的。

• SynchronousQueue（不存储数据、可用于传递数据）
  是一个不存储元素的阻塞队列。每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素。 SynchronousQueue 可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线 程。队列本身并不存储任何元素，非常适合于传递性场景,比如在一个线程中使用的数据，传递给 另 外 一 个 线 程 使 用 ， SynchronousQueue 的 吞 吐 量 高 于 LinkedBlockingQueue 和 ArrayBlockingQueue

• LinkedTransferQueue
  是一个由链表结构组成的无界阻塞 TransferQueue 队列。相对于其他阻塞队列， LinkedTransferQueue多了 tryTransfer和transfer方法。

  1. transfer 方法：如果当前有消费者正在等待接收元素（消费者使用 take()方法或带时间限制的 poll()方法时），transfer 方法可以把生产者传入的元素立刻 transfer（传输）给消费者。如 果没有消费者在等待接收元素，transfer 方法会将元素存放在队列的 tail 节点，并等到该元素 被消费者消费了才返回。
  2. tryTransfer 方法。则是用来试探下生产者传入的元素是否能直接传给消费者。如果没有消费 者等待接收元素，则返回 false。和 transfer 方法的区别是 tryTransfer 方法无论消费者是否 接收，方法立即返回。而transfer方法是必须等到消费者消费了才返回。

• LinkedBlockingDeque
  是一个由链表结构组成的双向阻塞队列。所谓双向队列指的你可以从队列的两端插入和移出元素。 双端队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比其 他的阻塞队列，LinkedBlockingDeque 多了 addFirst，addLast，offerFirst，offerLast， peekFirst，peekLast 等方法，以 First 单词结尾的方法，表示插入，获取（peek）或移除双端队 列的第一个元素。以 Last 单词结尾的方法，表示插入，获取或移除双端队列的最后一个元素。另 外插入方法add等同于addLast，移除方法remove 等效于removeFirst。但是take方法却等同 于takeFirst，不知道是不是Jdk的bug，使用时还是用带有First和Last后缀的方法更清楚。

---

拒绝策略

线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也 塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。

• AbortPolicy ： 抛出 RejectedExecutionException 异常，这是默认策略
• CallerRunsPolicy ： 只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的 任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极有可能会急剧下降。
• DiscardOldestPolicy ： 丢弃最老的一个请求，并尝试再次提交当前任务。
• DiscardPolicy ： 该策略默默地丢弃无法处理的任务，不予任何处理，即 放弃本次任务。如果允许任务丢失，这是最好的一种方案。

以上内置拒绝策略均实现了RejectedExecutionHandler接口，若以上策略仍无法满足实际 需要，完全可以自己扩展RejectedExecutionHandler接口。

---

JDK内置的线程池

一般创建方法：

ExecutorService executorService = Executors.newCachedThreadPool();

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

核心线程数是 0， 大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着 全部都是救急线程（60s 后可以回收），救急线程可以无限创建 。
队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交 货）

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {    
		return new ThreadPoolExecutor(nThreads, nThreads,
										0L, TimeUnit.MILLISECONDS,
										new LinkedBlockingQueue<Runnable>()); 
}

核心线程数 == 大线程数（没有救急线程被创建），因此也无需超时时间
阻塞队列是无界的，可以放任意数量的任务

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {    
			return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,
						0L, TimeUnit.MILLISECONDS,
						new LinkedBlockingQueue<Runnable>())); }

希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程 也不会被释放。
与newFixedThreadPool的区别：

• Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改
  FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了 ExecutorService
  接口，因 此不能调用ThreadPoolExecutor 中特有的方法
• Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改
  对外暴露的是ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改

newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);

   public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());
    }