线程池Executor框架解读

1. Executor 整体架构

接口/类	说明
Executor	该接口只有一个execute方法，目的是将任务提交和执行解耦
ExecutorService	该接口对Executor接口进行了拓展，定义了对线程池中线程的管理方法
AbstractExecutorService	对ExecutorService接口中部分方法的实现
ThreadPoolExecutor	线程池的最终实现，实现了线程池工作的完整机制，是整个框架的重点
ForkJoinPool	实现了Fork/Join模式的线程池
ScheduleExecutorService	对ExecutorService进行了拓展，定义了延迟执行和周期执行任务的方法
ScheduleThreadExecutorService	在继承ThreadPoolExecutorService的基础上对ScheduleExecutorService接口进行了实现

2. Executor 框架源码

2.1. Executor 接口

public interface Executor {
   

    void execute(Runnable command);
}

2.2. ExecutorService 接口

public interface ExecutorService extends Executor {
   

    void shutdown();

    List<Runnable> shutdownNow();

    boolean isShutdown();

    <T> Future<T> submit(Runnable task, T result);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

2.3. AbstractExecutorService 类

public abstract class AbstractExecutorService implements ExecutorService {
   
	
	protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
   
        return new FutureTask<T>(runnable, value);
    }

    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
   
        return new FutureTask<T>(callable);
    }

	public Future<?> submit(Runnable task) {
   
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Runnable task, T result) {
   
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }
	
	// ......
}

2.4. Executors 工具类

public class Executors {
   

	// 创建一个固定大小的线程池。每次提交一个任务，就创建一个线程。直到线程达到线程池的最大大小，线程池的大小一旦达到最大值就会保持不变
	// 如果某个线程因为执行异常而结束，那么线程池会补充一个新线程
	public static ExecutorService newFixedThreadPool(int nThreads) {
   
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

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

	// 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有的任务
	// 如果这个唯一的线程因为异常结束，那么会有一个新的线程来代替它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行
	// 单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的
	public static ExecutorService newSingleThreadExecutor() {
   
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

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

	// 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的的线程，那么就会回收部分空闲的线程
	// 当任务数增加时，此线程