为什么要用线程池

关于为什么要使用多线程，请参考【多线程与并发】：线程的创建、状态、方法中的最后一点。

那为什么要使用线程池呢？

①降低资源消耗：对象的创建和销毁是非常耗时的操作（线程也是一个对象）。通过重复利用已创建的线程降低线程创建和销毁造成的消耗；
②提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行；
③提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

线程池工作原理

这里是指jdk中的线程池实现。

1、线程池的主要处理流程

线程池处理流程.png

2、创建线程池

//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.corePoolSize = corePoolSize;                                      
    this.maximumPoolSize = maximumPoolSize;                                
    this.workQueue = workQueue;                                            
    this.keepAliveTime = unit.toNanos(keepAliveTime);                      
    this.threadFactory = threadFactory;                                    
    this.handler = handler;                                                
}                                                                          

参数解释

• corePoolSize（线程池的基本大小）：当提交一个任务时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，直到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreTreads()方法，线程池就会提前创建并启动所有基本线程。

• maximumPoolSize（线程最大数量）：线程池允许创建的最大线程数。如果队列已满，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。但如果使用了无解的任务队列，该参数没有效果。

• keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。如果任务很多，且每个任务执行时间较短，可调大该值。

• TimeUnit（线程活动保持时间的单位）：keepAliveTime的时间度量单位。可选天、小时、分钟、毫秒、微妙、纳秒。

• BlockingQueue<Runnable>（任务队列）：用于保存等待执行的任务的阻塞嘟列，可以选择以下几个阻塞队列

• ArrayBlockingQueue：基于数组结构的有界阻塞队列

• LinkedBlockingQueue：基于链表机构的阻塞队列，吞吐量通常高于ArrayBlockingQueue，静态工厂方法Executors.newFixedThreadPool()使用该队列。

• SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除，否则插入操作一直处于阻塞状态，吞吐量通常高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool()使用该队列。

• PriorityBlockingQueue：具有优先级的无限阻塞队列。

• ThreadFactory：创建线程的工厂。

• RejectedExecutionHandler：饱和策略，即队列和线程池都满了，对于新提交的任务无法执行，这时采取的处理新来的任务的方法，有4种策略可选（也可以自定义策略---实现RejectedExecutionHandler接口，如记录日志或持久化不能处理的任务）：

• CallerRunsPolicy：使用调用者所在的线程来运行任务。

• AbortPolicy：直接抛出RejectedExecutionException异常。（默认策略）

• DiscardPolicy：对新任务直接丢弃，不做任何事情

• DiscardOldestPolicy：丢掉队列里最近（the oldest unhandled）的一个任务，并执行当前新任务。

3、向线程池提交任务

有两种方式将任务提交给线程池来执行

• execute()
  用于提交不需要返回值的任务，所以无法判断任务是否被线程执行成功。

ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 20,
                30, TimeUnit.DAYS, new LinkedBlockingQueue<Runnable>());
threadPool.execute(new Runnable() {
            public void run() {
                //do something
            }
});

• submit()
  提交需要返回值的任务。线程池会返回一个Future类型的对象，通过这个对象可以判断任务是否执行成功，并且可以通过Future对象的get()方法来获取返回值。但get()方法会阻塞当前线程直到任务完成，使用get(long timeout, TimeUnit unit)方法会阻塞当前线程一段时间后立即返回（此时任务可能还没有执行完）。

 //有结果的任务
class TaskWithResult implements Callable<String>{
        @Override
        public String call() throws Exception {
            return "返回：我是实现有结果的任务";
        }
}
@org.junit.Test
public void test() throws ExecutionException, InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        Future<String> future = threadPool.submit(new TaskWithResult());
        System.out.println(future.isDone() ? "执行完了" : "没执行完呢");
        System.out.println(future.get());
        System.out.println(future.isDone() ? "执行完了" : "没执行完呢");
}
//输出为：
没执行完呢
返回：我是实现有结果的任务
执行完了

4、关闭线程池

调用线程池的两个方法来关闭shutdown()或者shutdownNow()：遍历线程池中的工作线程，然后逐个调用线程的interupt()方法中断线程，所以无法响应中断的任务可能永远无法终止。

• shutdownNow()
  不允许添加新的任务。立刻关闭线程池。不管池中是否还存在正在运行的任务。关闭顺序是先尝试关闭当前正在运行的任务。然后返回待完成任务的清单。已经运行的任务则不返回。（首先将线程池的状态设置为STOP，然后尝试终止所有的线程（包括正在执行任务或暂停任务的），并返回等待执行任务的列表；）
• shutdown()
  不允许添加新的任务，等池中所有的任务执行完毕之后再关闭线程池。
  （只是将线程池的状态设置为SHUTDOWN，然后中断所有没有正在执行任务的线程。）

//todo 有待验证shutdown()和shutdownNow()的区别

线程池框架Executor

1、简介

Executor是（since）JDK1.5实现的线程池技术。

先看Executor框架的主要类与接口

Executor主要类与接口.png

Future.png

Executor主要可以分为3个部分：

• 任务对象的创建：实现Runnable接口或实现Callable接口
• 任务的执行：接口ExecutorService、两个实现类ThreadPoolExecutor和ScheduledThreadPoolExecutor
• 异步计算的结果：接口Future以及实现类FutureTask

2、任务对象

• 两种方式创建任务对象：实现Runnable接口或实现Callable接口。
• 两者的区别：Runnable不会返回结果，Callable可以返回结果；Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常
• Runnable可以包装为Callable：通过Executors工具类提供的两个方法

public static <T> Callable<T> callable(Runnable task, T result);
public static Callable<Object> callable(Runnable task);

3、任务的执行

任务的执行是由两个实现类完成的：ThreadPoolExecutor和ScheduledThreadPoolExecutor。
前面介绍线程池工作过程就是以ThreadPoolExecutor为例进行的。在实际使用中，通常使用工具类Executors创建不同类型的ThreadPoolExecutor。
而ScheduledThreadPoolExecutor是ThreadPoolExecutor类的子类，相当于特定功能的扩展：在给定的延迟之后运行任务或者定期执行任务。它与Timer的功能类似，但更强大、更灵活。Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以指定多个线程数。

• ThreadPoolExecutor
  工具类Executors可以创建3中类型的ThreadPoolExecutor，分别如下。
• FixedThreadPool：可重用、固定线程数的线程池。

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

可以看出，
①FixedThreadPool的corePoolSize和maxmumPoolSize都被设置为
nThreads。
②keepAliveTime设为0，表示某工作线程一旦空闲，就立即关闭该工作线程。
③使用无界队列LinkedBlockingQueue，当线程池中的线程数达到corePoolSize后，新任务将会在无界队列中等待，因此线程数永远不会超过corePoolSize。
FixedThreadPool适用于为了满足资源管理的需求，而需要限制当前线程数量的场景，比如负载较重的服务器。

• SingleThreadExecutor：只有一个线程的线程池。

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

参数与FixedThreadPool的区别仅在于corePoolSize和maxmumPoolSize均为1，keepAliveTime和使用的阻塞队列都一样，特性类似，可以概括为：当有新任务时，如果线程池中没有线程，则创建一个线程，之后来的任务都存储在无界队列LinkedBlockingQueue中。该线程一直从队列中取任务执行。假如任务都执行完毕，立即终止该线程。
SingleThreadExecutor适用于需要保证顺序地执行各个任务，并且在任意时间点，不会有多个线程是活动的场景。

• CachedThreadPool：根据需要创建新的线程

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

①使用无容量队列SynchronousQueue，但maxmumPoolSize无界。如果提交任务的速度大于线程处理任务的速度，将会不断创建新线程，极端情况会因为创建过多线程而耗尽CPU资源。
②keepAliveTime为60s，空闲线程超过该时间将会终止。
③执行完任务的某线程会执行SynchronousQueue.poll()从队列中取任务，这个取的动作会持续60s，如果在60s内有新的任务，则执行新的任务，没有任务则终止线程。因此长时间保持空闲的CachedThreadPool不会占用任何资源。
④当有任务提交时，a.如果当前线程池为空或者已创建的线程都正在处理任务，则CachedThreadPool会创建新线程来执行该任务。b.如果当前线程池有空闲的线程（正在执行阻塞方法SynchronousQueue.poll()），则将任务交给该等待任务的空闲线程来执行。
CachedThreadPool适用于执行很多的短期异步任务的小程序或者是负载较轻的服务器。

• ScheduledThreadPoolEecutor
  先记住它是用来执行定期任务或者在给定延迟时间之后执行任务。其他待深入。

4、异步结果的获取

主要是通过接口Future和实现类FutureTask。

• Future
  Future代表了一个异步计算的结果。

public interface Future<V> {
//取消当前任务，如果任务已经完成，就会取消失败，返回false;
//如果取消成功，并且在调用该方法之前对应的任务还没有开始，
//则该任务永远也不会执行。如果任务正在执行，
//参数mayInterruptIfRunning设为true则表示将正在执行该任务的线程终止，
//参数mayInterruptIfRunning设为false则表示会等待任务完成。
//该方法返回true或false之后，之后的isDone()方法会返回true；
//如果该方法返回true，之后的isCancelled()方法也会返回true，
boolean cancel(boolean mayInterruptIfRunning);
//
//对应的任务是否在完成之前就取消了
boolean isCancelled();
//任务是否完成
boolean isDone();
//
//获取计算结果，如果任务还没执行完成，则会阻塞当前线程（调用该方法所在的线程），直到任务完成
V get() throws InterruptedException, ExecutionException;
//最多等待timeout就尝试取回结果
V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

JDK文档上给出的示例：

interface ArchiveSearcher { String search(String target); }
class App {
       ExecutorService executor = ...
       ArchiveSearcher searcher = ...
       public void showSearch(final String target)throws InterruptedException {
             Future<String> future= executor.submit(new Callable<String>() {
                  public String call() {
                      return searcher.search(target);
                  }
              });
             displayOtherThings(); // do other things while searching
             try {
                  displayText(future.get()); // use future
             } catch (ExecutionException ex) { cleanup(); return; }
       }
}

• FutureTask
  
  FutureTask继承关系图.png

FutureTask就像它的名字一样，既有Future的特点（实现Future接口），又具有任务的特点（实现Runnable接口）。更直白的理解是，FutureTask就是一种特殊的任务的描述类，利用FutureTask创建的任务可以获取计算结果。
FutureTask表示一个可取消的异步计算，并通过实现Future接口来开始或取消一个计算、查看计算是否完成、获取计算结果。如果计算还没有完成，调用FutureTask的get方法会阻塞当前线程（调用get方法所在的线程）。
FutureTask可以用来包装Callable和Runnable对象，因为实现了Runnable接口，所以FutureTask可以提交给Executor来执行（不提交就调用自己的run方法，也可以执行计算）。

FutureTask<String> future = new FutureTask<String>(new Callable<String>() {
       public String call() {
       return searcher.search(target);
}});
executor.execute(future);

作为一个独立的类，该类提供了很多protected的方法，以便创建你自己的定制任务类。

//todo 具体实现

说明：内容大多数摘抄自《Java并发编程的艺术》