线程池详解

简述

　　ThreadPoolExecutor是java线程池的一种

底层　

　　ThreadPoolExecutor 使用 int 的变量ctl的高 3 位来表示线程池状态，低29位表示线程数量

　　这些信息存储在一个原子变量 ctl 中，目的是将线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作进行赋值 

构造方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

　　corePoolSize 核心线程数目 (最多保留的线程数)

　　maximumPoolSize 最大线程数目

　　keepAliveTime 生存时间 - 针对救急线程

　　unit 时间单位 - 针对救急线程

　　workQueue 阻塞队列

　　threadFactory 线程工厂 - 可以为线程创建时起个好名字

　　handler 拒绝策略类

核心线程与救急线程

　　当核心线程都在执行任务时，新来的任务会进入阻塞队列，等待线程执行。当阻塞队列满了之后，后面再来的任务就会尝试寻找救急线程执行。当救急线程也都在执行任务时，线程池才会启动拒绝策略。当然救急线程平常是用不到的，所以我们设置keepAliveTime救急线程的生存时间来定时地回收线程。

拒绝策略

　　JDK的线程池有四种拒绝策略：

AbortPolicy（默认）	抛出异常
DiscardOldestPolicy	丢弃队列中最前面的任务，execute该线程。进入队列
DiscardPolicy	丢弃
CallerRunsPolicy	当前线程直接执行run方法

　　值得一提的是dubbo在抛出异常的同时会记录日志，netty会新创建一个线程执行任务，ActiveMQ会在一定时间内重复尝试，PinPoint会使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略

工厂方法创建线程池

　　JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池

newFixedThreadPool

　　这种创建方式的特点是没有救急线程被创建，因此也无需指定超时时间。阻塞队列是无界的，可以放置任意数量的任务。适用于任务量已知，相对耗时的任务。

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

newCachedThreadPool 

　　核心线程数是 0， 最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着该线程池里全部都是救急线程。该线程池的救急线程可以无限创建，队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
            60L, TimeUnit.SECONDS,
            new SynchronousQueue<Runnable>());
}

　　整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1分钟后释放线程。 适合任务数比较密集，但每个任务执行时间较短的情况

newSingleThreadExecutor 

　　希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建一个线程，保证池的正常工作

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

线程池提交任务

// 执行任务
void execute(Runnable command);

// 提交任务 task，用返回值 Future 获得任务执行结果
<T> Future<T> submit(Callable<T> task);

// 提交 tasks 中所有任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
 throws InterruptedException;

// 提交 tasks 中所有任务，带超时时间
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException;

// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
 throws InterruptedException, ExecutionException;

// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException, ExecutionException, TimeoutException;

关闭线程池　

　　使用shutdown方法关闭线程池，线程池状态变为 SHUTDOWN，不会接收新任务，但已提交任务会执行完、

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改线程池状态
        advanceRunState(SHUTDOWN);
        // 仅会打断空闲线程
        interruptIdleWorkers();
        onShutdown(); // 扩展点 ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    // 尝试终结(没有运行的线程可以立刻终结，如果还有运行的线程也不会等)
    tryTerminate();
}

　　使用shutdownNow关闭线程池，线程池状态变为 STOP，不会接收新任务，会将队列中的任务返回，并用 interrupt 的方式中断正在执行的任务

带任务调度的线程池

　　ScheduledExecutorService为我们提供了一个能进行任务调度的线程池，构造方法传入初始线程的数量。

　　它的schedule能够以定时器的方式延迟执行一个任务，参数为runnable或callable接口、延迟时间、时间单位

ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
pool.schedule(()->{
    System.out.println("task 1");
},1000, TimeUnit.SECONDS);
pool.shutdown();

　　它以固定时间频率执行任务，使用scheduleAtFixedRate即可，参数为任务、第一次执行的延迟时间、每次执行成功的间隔时间、时间单位。需要注意的是，如果执行时间大于间隔时间，则下一次执行就不会进行间隔，两个任务就会靠在一起执行。

ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
pool.scheduleAtFixedRate(()->{
    System.out.println("task 2");
},1,1,TimeUnit.SECONDS);
pool.shutdown();

　　scheduleWithFixedDelay参数一样，这个方法就不会考虑执行时间，每两个任务之间的间隔时间都是恒定的

　　另外如果调用了线程池的结束方法，则会停止定时执行的机制。

cpu密集型运算

　　指经常用到cpu的任务，线程池线程数通常采用 cpu 核数 + 1 能够实现最优的 CPU 利用率，+1 是保证当线程由于页缺失故障（操作系统）或其它原因导致暂停时，额外的这个线程就能顶上去，保证 CPU 时钟周期不被浪费

I/O 密集型运算

　　CPU 不总是处于繁忙状态，例如，当你执行业务计算时，这时候会使用 CPU 资源，但当你执行 I/O 操作时、远程RPC 调用时，包括进行数据库操作时，这时候 CPU 就闲下来了，你可以利用多线程提高它的利用率。　

　　经验公式如下：

线程数 = 核数 * 期望 CPU 利用率 * 总时间(CPU计算时间+等待时间) / CPU 计算时间

线程池的异常处理

　　在线程池中执行的任务如果出现了异常，线程池会怎么处理呢？答案是不会处理。线程池中运行的任务如果出现了异常，则会统一把异常交给afterExecute方法进行处理，但afterExecute方法是个空实现。也就是说，啥也不干。这也很好理解，设计线程池的时候怎么知道你具体运行的异常怎么处理呢。

　　第一种方法是直接在任务里加trycatch代码块，但这样子代码就会很丑。

　　第二种方法是设置每一个线程的异常处理类来达到异常处理的效果

ExecutorService pool = Executors.newFixedThreadPool(5);
Runnable task1 = new Runnable(){
    @Override
    public void run() {
        System.out.println("task1");
    }
};
Thread t1 = new Thread(task1);
t1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("异常处理");
    }
});
pool.execute(t1);

　　第三种方法是用submit提交callable任务，用futuretask的get方法返回异常信息，再进行统一处理