juc系列-Executor框架

什么是线程池

线程池：管理一组工作线程的资源池。

为什么使用线程池

1.避免反复创建回收线程，降低资源消耗。
2.提供线程的可管理性。
3.提高响应速度

如何创建线程池

ThreadPoolExecutor是jdk提供的线程池的服务类，基于ThreadPoolExecutor可以很容易将一个实现Runnable接口的任务放入线程池中执行，下面是ThreadPoolExecutor实现：

    //构造函数：
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

创建一个线程池需要以下几个参数：

• corePoolSize：线程池中线程的个数。
• maximumPoolSize：线程池最大容量。
• keepAliveTime：线程池中空闲存活时间（单位：TimeUnit定）
• workQueue：存放任务的工作队列。
• threadFactory：线程工厂
• handler：当任务数超过maximumPoolSize+corePoolSize后，任务交给handler处理。

1.corePoolSize

当客户端提交一个新任务时，如果此时线程池中线程的个数小于corePoolSize，则线程池会新建一个线程来处理该任务，即时此时有空闲线程。

2.maximumPoolSize

客户端提交新任务，此时线程池的任务队列也已经满了，那么如果maximumPoolSize < corePoolSize,就新建线程执行该任务。

如果线程池用的是无界队列，那么这个参数也就不起任何作用了。

3.keepAliveTime

线程池中超过corePoolSize的线程会在空闲keepAliveTime时间后被关闭，keepAliveTime单位由TimeUnit指定，如果allowCoreThreadTimeOut=true，即核心线程如果空闲时间超过keepAliveTime时间后同样会被关闭。

4.workQueue

当核心线程池已满，即当前worker数=corePoolSize时，新提交的任务会被放入工作队列中。此时一旦有worker完成手头的任务就会到workQueue中领取一个新任务继续执行。
工作队列可以有以下几种选择：

(1).ArrayBlockingQueue：基于数组的有界阻塞队列

(2).LinkedBlockingQueue：基于链表的阻塞队列，可以不指定队列大小,默认Integer.MAX_VALUE。性能高于ArrayBlockingQueue。

(3).SynchronousQueue

(4).PriorityBlockingQueue：具有优先级的阻塞列，基于数组实现，内部实际上实现了一个最小堆，每次offer、poll,都需要进行堆调整操作O(logn)。队列中元素需要实现Comparable接口或初始化队列时传入一个Comparator对象。虽然初始化队列时需指定队列大小，但PrioriityBlockingQueue支持动态扩容，所以可以认为是无限阻塞队列。

5.threadFactory

每当线程池需要创建一个线程时，都是通过线程工厂方法来完成。默认的线程工厂方法将创建一个新的、非守护的线程，并且不包含特殊配置信息。通过指定一个线程工厂方法，可以定制线程池的配置信息。
我们可以通过实现ThreadFactory接口，来定制线程工厂。样例如下：

public interface ThreadFactory {
    Thread newThread(Runnable r);
}
public class MyThreadFactory implements ThreadFactory {

    private final String poolName;

    public MyThreadFactory(String name){
        this.poolName = name;
    }
    @Override
    public Thread newThread(Runnable r) {
        // TODO Auto-generated method stub
        return new MyAppThread(r,poolName);
    }
}

public class MyAppThread extends Thread {
    public static final String DEFAULT_NAME = "MyAppThread";
    private static volatile boolean debugLifecycle = false;
    private static final AtomicInteger created = new AtomicInteger();

    private static final AtomicInteger alive = new AtomicInteger();

    public MyAppThread(Runnable r){
        this(r,DEFAULT_NAME);
    }
    public MyAppThread(Runnable r,String name){
        super(r,name + "-" + created.incrementAndGet());
        setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("UNCATGHT in Thread " + t.getName());
            }
        });
    }
    public void run(){
        try {
            alive.incrementAndGet();
            super.run();
        } finally{
            alive.decrementAndGet();
        }
    }
    public static int getThreadsCreated(){return created.get();}
    public static int getThreadAlive(){return alive.get();}
    public static boolean getDebug(){return debugLifecycle;}
}    

6.RejectedExecutionHandler

当线程池达到最大容量，饱和策略就发挥作用，ThreadPoolExecutor的饱和策略可以通过setRejectedExecutionHandler方法来修改。
JDK提供几种不同的RejectedExecutionHandler的实现：

• AbortPolicy：终止策略是默认饱和策略，直接抛出RejectedExecutionException。调用者可以捕获这个异常，并做相应处理。
• CallerRunsPolicy：“调用者运行”策略实现了一种调用机制，该策略不会抛弃任务，也不抛出异常，而是将任务退回调用者，从而降低新任务的流量
• DiscardPolicy：新任务无法入队列时，直接抛弃该任务。
• DiscardOldestPolicy：抛弃下一个将要被执行的任务，然后尝试重新提交新任务。（若工作队列是一个优先队列，那么“抛弃最旧的”策略导致抛弃优先级最高的任务。）

饱和策略实现类都需要实现RejectedExecutionHandler接口，下面是四种jdk内置的四种饱和策略的源码：

    public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() { }
        // 直接抛出RejectedExecutionException异常
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }
public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }
    
public static class DiscardPolicy implements RejectedExecutionHandler     {
        public DiscardPolicy() { }
        //不做操作，直接丢弃了
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }
    
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        public DiscardOldestPolicy() { }
        //抛弃队头的任务，即最早提交且未执行的任务
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }    

创建线程池

jdk为我们提供了一个工厂类Executors，其中提供了几个静态工厂方法用于新建不同特性的线程池。如下：

public class Executors {

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

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    
    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }    

• newFixedThreadPool：将创建一个固定长度的线程池，每提交一个任务时就创建一个线程，直到达到线程池的最大数量，此时线程池的规模不再变化（如果某个线程发生Exception而结束，那么线程池会补充一个新的线程）

• newCachedThreadPool：创建一个可缓存的线程池，如果当前线程池中线程的个数超过了处理需求时，那么空闲线程将被回收，而当需要增加线程时，则可以添加新的线程，线程池中个数不受限制（使用时格外注意，防止内存溢出）

• newSingleThreadPool：这是一个单线程的Executor，它创建单个工作线程来执行任务，如果线程异常结束，会创建一个新的线程来替代。newSingleThreadPool能确保依照任务在队列中的顺序串行执行。

• newScheduledThreadPool：创建一个固定长度的线程池，而且可以延时或定时方式来执行任务。

---

注意事项

1.newFixedThreadPool和newSingleThreadExecutor都是用了LinkedBlockingQueue(),默认capacity=Integer.MAX_VALUE，线程池工作队列可以认为是无限大的，所以线程池中的线程数不会超过CorePoolSize，maximumPoolSize可以认为是一个无效参数，且饱和策略不可能执行，这几点需要注意。

2.newFixedThreadPool(1)和newSingleThreadPool区别？

newSingleThreadPool返回的是一个代理对象，屏蔽了ThreadPoolExecutor的一些set方法，即newSingleThreadPool一旦返回，就无法在重新配置线程池的参数了。

3.CachedThreadPool的corePoolSize=0，即核心线程池默认为空，maximumPoolSize=Integer.MAX_VALUE,最大线程池为无限大的。且空闲线程等待新任务超过60秒即被终止。

---

Executor生命周期

由于Executor以异步方式来执行任务，因此在任意时刻，之前提交的任务的状态是无法立刻得到的。有些任务可能已经完成，有些可能正在运行，而其他的任务可能在队列中等待执行。

为了解决执行任务的生命周期问题，ExecutorService扩展了Executor接口，添加了一些生命周期管理的方法。如下：

void shutdown();
List<Runnable> shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
//  ...还有用于提交任务的一些方法

线程池的生命周期有以下几种状态

• RUNNING：接受新task，并且处理工作队列中的任务。
• SHUTDOWN：不接受新task，但是继续处理工作队列中的任务。
• STOP：不接受新task，不处理工作队列中的任务，并且中断运行中的线程。
• TIDYING：所有任务已被终止，线程池已清空（workerCount=0）,此时线程池状态变为TIDYING,并且准备执行terminated()方法。
• TERMINATED：以完成terminated()方法。

线程池如何存储自身状态的？

线程池的状态信息是用一个AtomicInteger类型的变量ctl存储的，定义如下：

    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

ctl中除了存放状态信息，还存放了线程池当前工作线程的个数信息。下图展示这两个信息在ctl中的存储形式：

下面是状态相关信息的源码，结合上图应该就不难理解了

    private static final int COUNT_BITS = Integer.SIZE - 3;//为啥减3
    //0-28位全为1
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // RUNNING ：  111。。。
    private static final int RUNNING    = -1 << COUNT_BITS;
    // SHUTDOWN ： 000。。。
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    // STOP     ： 001。。。
    private static final int STOP       =  1 << COUNT_BITS;
    // TIDYING ：  010。。。
    private static final int TIDYING    =  2 << COUNT_BITS;
    //TERMINATED ：110。。。
    private static final int TERMINATED =  3 << COUNT_BITS;

    // 通过简单的位运算获取ctl中的信息
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

runState有5种状态，所以最少需要3bit来表示。这就是为什么COUNT_BITS=32-3

各种状态之间的转换时机：

• RUNNING -> SHUTDOWN：调用shutdown()方法
• (RUNNING or SHUTDOWN) -> STOP：调用shutdownNow()
• SHUTDOWN -> TIDYING：线程池和工作队列都为空时
• STOP -> TIDYING：线程池为空时
• TIDYING -> TERMINATED：调用terminated()后

关闭线程池方法

• shutdown（）：不再接受新任务，同时已提交的任务执行完成，包括那些还在队列中等待，未开始执行的任务。
• shutdownNow（）：将取消所有运行中的任务，并且不再启动队列中尚未开始执行的任务。之后再提交任务则抛出异常：java.util.concurrent.RejectedExecutionException。

线程池工作流程

线程池处理新提交任务的流程如下：

1. 如果当前运行的线程数小于配置的corePoolSize，就新建一个线程执行该command任务，即时此时线程池中有空闲线程。

2. 如果线程池中线程个数达到corePoolSize，新提交的任务就被放入workQueue，等待线程池任务调度。

3. 当workQueue满后，且maximumPoolSize > corePoolSize，新提交任务会创建新线程执行任务

4. 当workQueue满后，且线程池个数达到maximumPoolSize，则提交的任务交由RejectedExecutionHandler处理。

5. 超过corePoolSize的线程，在空闲keepAliveTime时间后，将被关闭。

6. 当allowCoreThreadTimeOut=true时，corePoolSize个数内的线程空闲时间达到keepAliveTime后，也将被关闭。

ThreadPoolExecutor 中execute源码：如下：

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {//新建线程执行任务
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {//提交到工作队列
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))//
            reject(command);
    }

线程池监控

//线程池已完成任务数量
private long completedTaskCount;
//当前运行的线程数
public int getActiveCount()    

此外，ThreadPoolExecutor还提供了以下几个钩子函数用于扩展它的行为,我们可以在子类中实现自己的逻辑，在每个任务执行的前、后以及worker退出时进行定制处理。

protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }
protected void terminated() { }

线程的生命周期

下面从线程池中的某个线程的角度出发，分析一下线程从被创建一直到被销毁，整个生命周期里的工作流程

1. 线程的创建时机

• 提交任务时被创建（即客户端调用submit方法）。不过提交任务未必一定会创建线程，这在前面线程池的工作流程里已经提到。
• 预先启动线程池中核心线程池。（如：调用prestartCoreThread、prestartAllCoreThreads()等方法），下面是prestartAllCoreThreads的源码

public int prestartAllCoreThreads() {
        int n = 0;
        while (addWorker(null, true))//firstTask为null
            ++n;
        return n;
}

2. 线程在线程池中的数据结构

线程池中的工作线程是被封装到一个Worker类中，部分源码如下：

private final class Worker  extends AbstractQueuedSynchronizer
        implements Runnable
    {

        /** worker关联的线程 */
        final Thread thread;
        /** worker的第一个任务,可能为null */
        Runnable firstTask;
        /** worker完成的任务数量 */
        volatile long completedTasks;

        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** 将任务代理给runWorker方法  */
        public void run() {
            runWorker(this);
        }
        。。。。
    }
    
//下面是ThreadPoolExecutor中的runWorker方法源码：
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);//钩子函数
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);//钩子函数
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

当firstTassk为null的情况下，线程的执行流程如下图

对于Executor框架，需要明白以下两点

Executor框架基于生产者-消费者模式：提交任务的执行者是生成者，执行任务的线程是消费者。

Executor是异步执行任务，这是通过队列来实现的。