线程池如何复用一个线程-- ThreadPoolExecutor的实现（未完）

任务是一组逻辑工作单元，而线程则是使任务异步执行的机制。在Java中，Runnable对象代表一个任务，Thread对象负责创建一个线程执行这个任务。

前提：1. 程序需要处理大量任务

　　　2. 任务的执行时间相对创建线程和销毁的时间较短

方法1:

while (ture) {
　　Socket connection = socket.accept();
　　handleTask(connection);  //单线程处理所用任务

方法2:

while (true) {
　　final Socket connection = socket.accept();
　　new Thread(() -> {handleTask(connection);}).start(); 每个任务一个线程处理
}

两种方法的缺点：1. 串行执行的问题在于响应慢，在多核处理器上吞吐量小。

　　　　　　　　2. 无限创建线程导致资源消耗大，可创建线程数有限制，恶意提交任务会导致程序负载过高。

Java的第3种解决方案是线程池，它是兼顾资源和并发的处理方案。

线程池的关键是任务的执行策略，复用线程。

执行策略定义了：

　　~ 任务在哪个线程上运行

　　~ 任务按照什么顺序执行(FIFO, LIFO, 优先级）

　　~ 有多少个任务可以并发执行

　　~ 队列中有多少个任务等待执行

　　~ 系统由于过载而需要拒绝一个任务时，选择哪个任务，如何通过程序有任务被拒绝

　　~ 任务执行前后，应该进行哪些动作。

线程池的优势：

　　1. 重用线程，减少了创建和销毁线程的开销，在Window和Linux，Java使用一个线程对应一个轻量级进程的实现。

　 2. 某些情况下，任务到达时，如果有空闲线程，可以立即执行任务，而不需要等待创建新线程，提高响应速度。

　　3. 线程池的大小可以调节，以便处理器保持忙碌状态，提高效率。

　　4. 通过将任务的提交和执行分离，可以根据硬件资源选择最佳的执行策略。

线程池的实现：

　　在java.util.concurrent包中，ThreadPoolExecutor是一个线程池实现。

图中的三个接口：

Executor：一个运行新任务的简单接口；public interface Executor {

/**
     * 在未来的某个时间执行任务command.  这个任务可能在一个新的线程中执行 ，
     * 或者在线程池中的线程执行，或者一个调用线程中执行（即在main中运行)。　　　
     * 取决于线程池的具体实现
     * @param 需要执行的任务
*/
    void execute(Runnable command);
}

ExecutorService：扩展Executor接口

public interface ExecutorService extends Executor {

    void shutdown(); // 停止接受任务。
    List<Runnable> shutdownNow(); // 尝试停止所有活动的任务
    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,long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

ScheduledExecutorService：扩展了ExecutorService。支持Future和定期执行任务。

ThreadPoolExceutor源码：

1. 关键field

 // 线程池状态初始化为处于运行状态，线程数为0.
 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); // 储存运行状态和线程数(刚创建的线程处理RUNNING，0个活动线程。
 private static final int COUNT_BITS = Integer.SIZE - 3;      // Integer.SIZE = 32 COUNT_BITS = 29
 // 线程池的线程数
 private static final int CAPACITY   = (1 << COUNT_BITS) - 1;   // 0x000 1111 1111 1111 1111 1111 1111 1111

 // 运行状态储存在高位中
 private static final int RUNNING    = -1 << COUNT_BITS; // 0x111 0000 0000 0000 0000 0000 0000 0000
 private static final int SHUTDOWN   =  0 << COUNT_BITS; // 0x000 0000 0000 0000 0000 0000 0000 0000
 private static final int STOP       =  1 << COUNT_BITS; // 0x001 0000 0000 0000 0000 0000 0000 0000
 private static final int TIDYING    =  2 << COUNT_BITS; // 0x0100 0000 0000 0000 0000 0000 0000 0000 
 private static final int TERMINATED =  3 << COUNT_BITS; // 0x011 0000 0000 0000 0000 0000 0000 0000

 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; }       // 获取运行状态和线程数

线程池的五种状态：

RUNNING: 运行状态，接受新提交的任务，并且可以处理队列中的任务。

SHUTDOWN: 关闭状态，不再接受新提交的任务，可以处理队列中的任务。在线程池处于

　　　　　　 RUNNING状态时，调用shutdown()方法会使线程池进入到此状态。

STOP：停止状态，不再接受新提交的任务，也不处理队列中的任务，并且中断运行中的任务。

　　     在RUNNING或SHUTDOWN状态时，调用shutdownNow()方法使线程池进入到该状态。

TIDYING： 所有任务都己终止，workerCount为0, 转换到TIDYING状态的线程池将运行terminate()方法。

TERMINATE: 终止状态，terminated()方法调用后进入此状态。

private final BlockingQueue<Runnable> workQueue;
private final HashSet<Worker> workers = new HashSet<>();
private volatile ThreadFactory threadFactory;

workQueue用于保存任务

workers用于保存工作线程

threadFactory用于生产线程。

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.acc = System.getSecurityManager() == null ?
                null : AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize: 线程池核心线程数量，作用：

　　* 当新任务在execute()提交时，根据corePoolSize去判断任务如何执行：

　　　　-> 如果线程池中线程小于corePoolSize，创建新的线程处理此任务，即使线程池中有空闲线程

　　　　-> 如果线程池中线程数大于等于corePoolSize且workQueue未满时，任务添加到workQueue中。

　　　　-> 如果线程池中线程数大于等于corePoolSize且workQueue己满时，创建新线程处理任务。

　　　　-> 如果线程池中线程数大于等于maximunPoolSize，且workQueue已满时，通过指定的handler策略处理任务(有四种已定义的策略）

maximumPoolSize：最大线程数量

workQueue：未处理的任务队列

keepAliveTime：当线程池中的线程数量大于corePoolSize的时候，多余的线程不会立即销毁，而是会等待，

　　　　　　　　直到等待的时间超过了　keepAliveTime

threadFactory：用于创建新线程，通过ThreadFactory可以

handler：当线程池的的线程数等于maximumPoolSize且workQueue己满时，使用handler处理新提交的线程

execute方法，实现执行任务的逻辑。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * 分3步处理任务:
         * 1.线程数小于corePoolSize时，创建新线程执行此任务。
         * addWorker 方法自动检查runState和workerCount
         * addWorker因为不能添加线程时，返回false
         *
         * 2. 如果可以添加到队列, 我们仍要再次检查线程池的状态
　　　　　 * （因为线程池中可能没有线程 或者在进入此方法时，线程池被关闭了。
         *　如果线程池不处于RUNNING，清除刚才添加的任务
　　　　　 * 如果处于RUNNING且workerCount=0,创建新线程。
　　　　　 *
         * 3.如果不能将任务添加到队列, 就尝试创建一个新的线程。如果创建失败，拒绝任务
         */
        int c = ctl.get(); // 获取线程池的运行状态和线程数
        if (workerCountOf(c) < corePoolSize) { // 如果线程数小于corePoolSize时
　　　　　　　// 第二个参数表示，限制添加线程的数量由谁决定
　　　　　　　// true 由corePoolSize
　　　　　　　// false 由maximumPoolSize
           if (addWorker(command, true))
                return;                        // 添加成功
            c = ctl.get();                     // 添加线程失败时，重新获取运行状态和线程数
        }
　　　　　// 线程池处于RUNNING状态且任务成功添加到workQueue
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();           // 重新获取运行状态和线程数,
　　　　　　　 // 重新判断运行状态，如果不是处于运行状态，移除上面调用workQueue.offer(command)时，添加的任务。
            // 并且拒绝此任务
　　　　　　　 if (! isRunning(recheck) && remove(command))
                reject(command);
　　　　　　　 // 如果处于运行状态，且线程数为0时
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);    // 在线程中添加线程去执行此任务。
        }
　　　　  // 如果线程池不是运行状态或者添加任务失败，且创建线程的失败时，
        else if (!addWorker(command, false))
            reject(command);               // 拒绝此任务
    }

 addWrok方法，实现增加线程的逻辑

　　检查是否可以根据当前线程池状态和给定边界（核心或最大线程数）添加新工作线程。 如果是，则相应地调整工作线程的计数，并且如果可能，创建并启动新工作程序，将firstTask作为其第一个任务运行。 如果线程池已停止或可以关闭，则此方法返回false。 如果线程工厂在询问时无法创建线程，它也会返回false。 如果线程创建失败，或者由于线程工厂返回null，或者由于异常（通常是Thread.start（）中的OutOfMemoryError）会回滚

   private boolean addWorker(Runnable firstTask, boolean core) {     
　　　　　retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);  //获取运行状态

     　　　　// 运行状态为RUNNING时，可以执行任务，跳出if
　　　　　　　// 处于SHUTDOWN状态，fisrtTask为null,workQueue不为空时，跳出if
            if (rs >= SHUTDOWN &&    // 不处于RUNNING,继续判断，否则跳出if
                ! (rs == SHUTDOWN && // 如果处于SHUTDOWN状态，继续判断，否则返回false
                   firstTask == null && // fisrtTask为空，继续判断，否则返回false
                   ! workQueue.isEmpty())) // workQueue为空时，返回false，否则跳出if
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||  // 工作线程数大于CAPACITY时，返回false
                    wc >= (core ? corePoolSize : maximumPoolSize)) // 小于CAPACITY，大于core或max时，返回false
                    return false;
                if (compareAndIncrementWorkerCount(c)) // 如果添加线程成功，跳出第一个for循环
                    break retry;
                c = ctl.get();  // Re-read ctl  添加失败，重新读取状态
                if (runStateOf(c) != rs)       // 不是RUNNING状态， 重新跑到第一个for循环。
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);  // 用firstTask创建一个新的Worker
            final Thread t = w.thread;  // Worker利用ThreadFactory创建一个线程对象储存在其实例thread中
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());
　　　　　　　　　　　　// 如果处于运行状态，或者 处于关闭状态但任务为null时
                    if (rs < SHUTDOWN ||  (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // 判断线程是否处于已经调用start()，如果是，抛出异常
                            throw new IllegalThreadStateException();
                        workers.add(w);  // 将工作线程添加到Hashset中
                        int s = workers.size();
                        if (s > largestPoolSize) // 记录线程池中出现过最大的线程数
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();  // 启动线程， t.start()调用的是Worker的run方法，见worker的构造器。
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }