Java threadPool

创建线程的几种方式

1. 继承 Thread
2. 实现 Runnable 接口run方法
3. 实现 Callable接口call方法
4. 使用线程池

为什么使用线程池，线程池的优势？

• 线程池用于多线程处理中，它可以根据系统的情况，可以有效控制线程执行的数量，优化运行效果。
• 线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，那么超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

主要特点为：

1. 线程复用
2. 控制最大并发数量
3. 管理线程

主要优点

1. 降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
2. 提高相应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅仅会消耗系统资源，还会降低系统的稳定性，使用线程可以进行统一分配，调优和监控。

线程池的架构

• 其中ThreadPoolExecutor是最重要的类，作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务。
• 几种线程池都是用它来new线程池，如下所示：

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

主要的线程池

1. Executors.newFixedThreadPool(int)
   拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待
   适用于执行长期的任务
2. Executors.newSingleThreadExecutor()
   只有一个线程的线程池，因此所有提交的任务是顺序执行
3. Executors.newCachedThreadPool()
   线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除
   适用于执行很多短期异步的小程序或者负载较轻的服务器
4. Executors.newScheduledThreadPool()
   用来调度即将执行的任务的线程池
5. Executors.newWorkStealingPool(int)
   Java8新出的
   适合使用在很耗时的操作，但是newWorkStealingPool不是ThreadPoolExecutor的扩展，它是新的线程池类ForkJoinPool的扩展，但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），所以适合使用在很耗时的任务中

使用示例

ExecutorService threadPool = Executors.newFixedThreadPool(5);
ExecutorService threadPool = Executors.newSingleThreadExecutor();
ExecutorService threadPool = Executors.newCachedThreadPool();

try{
    for(int i = 0; i < 20; i++){
        threadPool.execute(() -> {
            System.out.println(Thread.currentThread().getName() + "\t doing...");
        });
        //也可以使用下面两种
        <T> Future<T> submit(Callable<T> task);
        <T> Future<T> submit(Runnable task, T result);
    }
}catch (Exception e){
    e.printStackTrace();
}finally {
    threadPool.shutdown();
}

线程池的7个重要参数

1. corePoolSize 核心线程池大小
2. maximumPoolSize 最大线程池大小
3. keepAliveTime 线程池中多余的空闲线程存活时间
4. TimeUnit keepAliveTime的单位
5. workQueue 任务阻塞队列 提交的任务超过了核心线程池大小，就会阻塞到队列
6. threadFactory 线程工厂
7. RejectedExecutionHandler 拒绝策略
   当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理

线程池的底层工作原理？

• 当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
• 当线程池达到corePoolSize时，新提交任务将被放入 workQueue 中，等待线程池中任务调度执行。
• 当workQueue已满，且 maximumPoolSize 大于 corePoolSize 时，新提交任务会创建新线程执行任务。
• 当提交任务数超过 maximumPoolSize 时，新提交任务由RejectedExecutionHandler 处理。
• 当线程池中超过corePoolSize 线程，空闲时间达到 keepAliveTime 时，关闭空闲线程，直到只剩下corePoolSize个线程为止
• 当设置allowCoreThreadTimeOut(true) 时，线程池中 corePoolSize 线程空闲时间达到 keepAliveTime 也将关闭。

线程池的拒绝策略

1. AbortPolicy：处理程序遭到拒绝将抛出运行时 RejectedExecutionException
2. CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。简单说就是，让创建这个任务的那个线程（caller）去执行
3. DiscardPolicy：不能执行的任务将被删除
4. DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）

工作中三种创建线程池的方法，你用哪个多？（超级大坑）

• newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。
• 这个问题主要体现在newFixedThreadPool和newSingleThreadExecutor两个工厂方法上，并不是说newCachedThreadPool和newScheduledThreadPool这两个方法就安全了，这两种方式创建的最大线程数可能是Integer.MAX_VALUE，而创建这么多线程，必然就有可能导致OOM。
• 所以工作中一般都是自定义线程池

自定义线程池

如下所示：

ExecutorService threadPool = new ThreadPoolExecutor(
                2, // 核心线程数
                5, // 最大线程数
                1L, // keepAliveTime   
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy()
//                new ThreadPoolExecutor.CallerRunsPolicy()
//                new ThreadPoolExecutor.DiscardOldestPolicy()
                new ThreadPoolExecutor.DiscardPolicy()
        );

合理配置线程池你是如果考虑的？

• 先通过Runtime.getRuntime().availableProcessors()了解我的服务器CPU核数
  • CPU 密集型
    • CPU 密集是指该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
    • 为了减少线程切换，CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。
  • IO 密集型
    • IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2 。
    • 也可以使用公式：CPU 核数 / (1 - 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。比如8核CPU：8 / （1 - 0.9）= 80

问：如果采用AbortPolicy，线程池的最大支持任务数是多少？

• 阻塞队列容量+最大线程数