类图：
其实从类图我们能发现concurrent包（除去java.util.concurrent.atomic 和 java.util.concurrent.locks）中的内容并没有特别多，大概分为四类：BlockingQueue阻塞队列体系、Executor线程组执行框架、Future线程返回值体系、其他各种单独的并发工具等。
首先学习的是Executor体系，是我们处理多线程最常接触的内容。首先我们单独看下继承体系：
Executor是顶级接口，里面只有一个方法：
public interface Executor {
void execute(Runnable command);－－－执行一个Runnable对象，Runnable在前面的文章里面已经讲到，是线程的顶级接口，里面有个run方法
}
ExecutorService是我们经常用到的多线程执行框架的声明，源码也很少，我们逐个方法进行解释：
public interface ExecutorService extends Executor {
void shutdown();－－－－关闭线程执行框架中的线程，但效果是不再接受新线程加入，并且等待线程执行结束后关闭Executor
List<Runnable> shutdownNow();－－－大体同上的，但是该命令会尝试关闭正在运行中的线程，但是也仅仅是调用terminate方法然后让jdk去决定是否结束，同时该方法返回那些awaiting状态的线程组
boolean isShutdown();－－－是否已经被关闭的状态
boolean isTerminated();－－－是否已经被中止的状态，在shutdown和shutdownnow被调用后，并且线程全部执行结束，该状态才是true，否则都是false
boolean awaitTermination(long timeout, TimeUnit unit) －－－如果线程组terminate了，返回true,超时时间到了返回false。
throws InterruptedException;
<T> Future<T> submit(Callable<T> task);－－提交一个Callable的回调，然后执行完成后将结果放入Future对象。
<T> Future<T> submit(Runnable task, T result);－－提交一个Runnable接口实现，然后result是Future返回值
Future<?> submit(Runnable task);－－提交一个Runnable接口实现，如果执行完成，future.get()可以返回一个null
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)－－执行提交的Callable集合，然后返回各自的执行结果的Future对象列表，每个元素isDone都是true
throws InterruptedException;
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)－－执行提交的task集合，执行完成或者timeout之后返回结果，isDone为true
throws InterruptedException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks)－－执行提交的task集合，有一个执行完成就返回结果
throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)－－同上，有一个执行完成或者有timeout出现
throws InterruptedException, ExecutionException, TimeoutException;
AbstractExecutorService实现了ExecutorService接口，并且声明为抽象类，然而其中一个抽象方法都没有。。.
public abstract class AbstractExecutorService implements ExecutorService {
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {---为子类定义了一个创建RunnableFuture对象的快捷方法
return new FutureTask<T>(runnable, value);
}
－－－其余方法都是接口的实现方法
}
还有一个继承了ExecutorService的接口的接口：
public interface ScheduledExecutorService extends ExecutorService { －－－定义延迟执行的动作 public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit); －－－延迟delay个时间单位后开始执行 public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);－－－延迟delay个时间单位后执行并返回Future对象 public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);在initialDelay、initialDelay＋N*period分别出发 public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit); }－－initialDelay开始进行，后面每次执行成功后的dealy时间单位开始
接下来是重磅的内容ThreadPoolExecutor 也就是Executor框架的核心逻辑所在，ThreadPoolExecutor类算上注释有2100多行，但里面有很多一部分是方法的详细说明，还有大量的变量和private/protected的方法，真正开放出来的public方法很少，我们只要逐个分析这些public方法就可以了。
我们首先来看构造函数，构造函数有多个重载方法，目前只看参数最全的情况：
public ThreadPoolExecutor(int corePoolSize, －－－－池子里面的线程数量，即便idle状态的线程也会保留这个数量 int maximumPoolSize,－－－－池子里面能盛放最大线程数量 long keepAliveTime,－－－－当线程数量大于core核心数量的时候，并且里有idle状态的线程，那么最大可以被terminate的的等待时间
（就是在cpu借的线程资源如果闲置多久就必须还回去） TimeUnit unit,－－timeUnit 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; }
public void execute(Runnable command) {}---执行一个任务
public void shutdown() {－－－使用可重入锁实现，关闭线程池执行框架，不再接受新的任务，关闭idle状态的线程，等待正在执行的执行完成。
final ReentrantLock mainLock = this.mainLock;
}
public List<Runnable> shutdownNow() {}--- 同ExecutorService中的接口说明，与shuwdown的区别在于会尝试关闭正在执行的线程
public boolean isShutdown() {}－－－是否已经关闭（没有running状态的线程了）
－－－－－－－一堆get和set方法
public int getActiveCount() {}－－－获得活动的线程数量
public long getCompletedTaskCount() {}－－－或者完成的任务数量
其实我们只要知道ThreadPoolExecutor的构造参数就可以明白它的工作方式，而且我们需要做的也是把这些内容构造好。
我们最常用的Executors里面的更加方便的Pool的类型其实都是为我们加了一些default参数的ThreadPoolExecutor：
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 newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1, threadFactory));
}
也就是其实最后都是会到ThreadPoolExecutor上面去实现，区别就是一个用着方便，一个你可以控制的粒度更小，进而可能效率更高。
我们在类图的继承体系里面还能发现一个叫做ForkJoinPool的类，这个类其实是很多人口中所谓未来java并发方向的类，由于涉及的内容较多，后面单独随笔进行学习和理解吧。