ThreadPoolExecutor类的认识和了解

java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类。
那么我们就先来看看这个类的源码：

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
                long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
                long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
                ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
    			long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
    			RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
    			long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
    			ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

下面我来解释一下这些构造方法中的一些参数的意思
1、corePoolSize：核心池的大小；
2、maximumPoolSize：线程池最大线程数，这个参数是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
3、keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
4、unit：参数keepAliveTime的时间单位，它有7种取值，在TimeUnit类中有7种静态属性：

1. TimeUnit.DAYS; //天
2. TimeUnit.HOURS; //小时
3. TimeUnit.MINUTES; //分钟
4. TimeUnit.SECONDS; //秒
5. TimeUnit.MILLISECONDS; //毫秒
6. TimeUnit.MICROSECONDS; //微秒
7. TimeUnit.NANOSECONDS; //纳秒

5、workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：ArrayBlockingQueue;LinkedBlockingQueue;SynchronousQueue。
ArrayBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。
6、threadFactory：线程工厂，主要用来创建线程；
7、handler：表示当拒绝处理任务时的策略。具体细节我们以后再讲。

现在我们来看整个代码，这个类是继承了AbstractExecutorService类。那我们来看看AbstractExecutorService类的源码：

public abstract class AbstractExecutorService implements ExecutorService {     
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { };
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { };
    public Future<?> submit(Runnable task) {};
    public <T> Future<T> submit(Runnable task, T result) { };
    public <T> Future<T> submit(Callable<T> task) { };
    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                            boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                           long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                         long timeout, TimeUnit unit)
        throws InterruptedException {
    };
}

而AbstractExecutorService是实现了ExecutorService接口，那么我们再来看看ExecutorService接口的源码：

public interface ExecutorService extends Executor {
    void shutdown();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)throws InterruptedException;
    
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <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;
}

由此类推，我们来看看Executor类的源码：

public interface Executor {
    void execute(Runnable command);
}