四种常用线程池及自定义线程池参数详细分析

一、什么是线程池

线程池（英语：threadpool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
例如，线程数一般取cpu数量+2比较合适，线程数过多会导致额外的线程切换开销。 ----百度百科

一个ExecutorService ，使用可能的几个合并的线程执行每个提交的任务，通常使用Executors工厂方法配置。
线程池解决两个不同的问题：由于每个任务的调用开销减少，它们通常在执行大量异步任务时提供改进的性能，并且它们提供了一种限制和管理资源（包括执行一个任务。 每个ThreadPoolExecutor还维护一些基本统计信息，例如已完成任务的数量。

二、常用的更方便的Executors工厂方法

Executors.newCachedThreadPool() （无限线程池，具有自动线程回收）， Executors.newFixedThreadPool(int) （固定大小的线程池）和Executors.newSingleThreadExecutor() （单个后台线程），Executors.newScheduledThread(int) (可以调度命令在给定的延迟之后运行，或定期执行) 可以预先配置最常用的使用场景设置。

1. Executors.newCacheThreadPool()

可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用，如果没有，就创建一个新的线程加入池中，通常用于执行一些生存期很短的异步型任务

public class ThreadTask {

    public static void main( String[] args ) {

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for(int i=0;i<=10;i++) {
            try {
                // sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(() ->System.out.println(Thread.currentThread().getName()));

        }
    }
}

运行结果：

线程池为无限大，当执行完当前任务时，会复用上一次任务的线程，不会重新创建新的线程

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

核心线程0，最大线程Integer.MAX_VALUE,底层队列：SynchronizedQueue

2. Executors.newFixedThreadPool(int n)

创建一个可重用固定个数的线程池，以共享的无界队列运行这些线程，定长线程池的大小最好根据系统的资源进行设置。Runtime.getRuntime().availableProcessors()

public class ThreadTask {

   public static void main( String[] args ) {
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
     	for(int i=0;i<=10;i++) {

            try {
                newFixedThreadPool.execute(() ->System.out.println(Thread.currentThread().getName()));
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

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

核心线程=最大线程，固定大小的线程池。底层队列：LinkedBlockingQueue

3. Execotors.newSingThreadExecutor()

创建一个单线程的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO,LIFO）执行

public class ThreadTask {
    public static void main( String[] args ) {
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for(int i = 0;i <= 10;i++) {
            final int index = i;
             try {
                 // 依次输出结果
                newSingleThreadExecutor.execute(() ->System.out.println(Thread.currentThread().getName()+"正在打印"+index));
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

核心线程，最大线程数都是1，底层队列：LinkedBlockingQueue

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

4. Executors.newScheduledThread(int n)

创建一个定长线程池，支持定时及周期性任务执行

public class ThreadTask {
    public static void main( String[] args ) {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(3);
        newScheduledThreadPool.scheduleAtFixedRate(()->System.out.println("延迟1秒，每2秒执行一次"),1,2,TimeUnit.SECONDS);
    }
}

执行结果：

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

底层队列：DelayedWorkQueue

三、自定义线程池

可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池。
常见的构造函数：

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

创建一个新的 ThreadPoolExecutor与给定的初始参数。

参数
corePoolSize - 即使空闲时仍保留在池中的线程数，除非设置allowCoreThreadTimeOut
maximumPoolSize - 池中允许的最大线程数
keepAliveTime - 当线程数大于内核时，这是多余的空闲线程在终止前等待新任务的最大时间。
unit - keepAliveTime参数的时间单位
workQueue - 用于在执行任务之前使用的队列。 这个队列将仅保存execute方法提交的Runnable任务。
threadFactory - 执行程序创建新线程时使用的工厂
handler - 执行被阻止时使用的处理程序，因为达到线程限制和队列容量

异常
IllegalArgumentException - 如果以下某项成立：
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize
NullPointerException - 如果 workQueue或 threadFactory或 handler为空

• 当方法execute(Runnable)中提交了新任务，并且运行的corePoolSize线程少于一个，即使其他工作线程处于空闲状态，也会创建一个新的线程来处理该请求。
• 如果超过corePoolSize但小于maximumPoolSize线程运行，则仅当队列已满时才会创建一个新线程。
• 通过将corePoolSize和maximumPoolSize设置为相同，您将创建一个固定大小的线程池。
• 通过将maximumPoolSize设置为本质上无限制的值（如Integer.MAX_VALUE ，您可以允许池容纳任意数量的并发任务。
• 最重要的是，核心和最大池大小只能在构建时进行设置，但也可以使用setCorePoolSize(int)和setMaximumPoolSize(int)进行动态更改。
• 如果运行的线程数量大于等于maximumPoolSize，这时如果workQueue已经满了，则通过handler所指定的策略来处理任务；

四、缓冲队列BlockingQueue

任何BlockingQueue可用于传送和保留提交的任务。 这个队列的使用与池大小相互作用：

• 如果少于corePoolSize线程正在运行，Executor总是喜欢添加一个新线程，而不是排队。
• 如果corePoolSize或更多的线程正在运行，Executor总是喜欢排队请求而不是添加一个新的线程。
• 如果请求无法排队，则会创建一个新线程，除非这将超出maximumPoolSize，否则任务将被拒绝。

ArrayBlockingQueue(int i)：规定大小，FIFO顺序，有界队列
LinkedBlockingQueue（）或者（int i）:无界队列，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。

SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

五、 排队的三种一般策略

1. 直接切换 一个工作队列的一个很好的默认选择是一个SynchronousQueue ，将任务交给线程，无需另外控制。在这里，如果没有线程可以立即运行，那么尝试排队任务会失败，因此将构建一个新的线程。
   处理可能具有内部依赖关系的请求集时，此策略可避免锁定。直接切换通常需要无限制的maximumPoolSizes，以避免拒绝新提交的任务。
   这反过来允许无限线程增长的可能性，当命令继续以平均速度比他们可以处理的速度更快地到达时。
2. 无界队列 使用无界队列（例如LinkedBlockingQueue没有预定容量）会导致新的任务，在队列中等待，当所有corePoolSize线程都很忙。 因此，不会再创建corePoolSize线程。 （因此，最大值大小的值没有任何影响。）每个任务完全独立于其他任务时，这可能是适当的，因此任务不会影响其他执行; 例如，在网页服务器中。 虽然这种排队风格可以有助于平滑瞬态突发的请求，但是当命令继续达到的平均速度比可以处理的速度更快时，它承认无界工作队列增长的可能性。
3. 有边界的队列。 有限队列（例如， ArrayBlockingQueue ）有助于在使用有限maxPoolSizes时防止资源耗尽，但可能更难调整和控制。 队列大小和最大池大小可能彼此交易：使用大队列和小型池可以最大限度地减少CPU使用率，OS资源和上下文切换开销，但可能导致人为的低吞吐量。 如果任务频繁阻塞（例如，如果它们是I / O绑定），则系统可能能够安排比您允许的更多线程的时间。 使用小型队列通常需要较大的池大小，这样可以使CPU繁忙，但可能会遇到不可接受的调度开销，这也降低了吞吐量。

六、拒绝策略

方法execute(Runnable)中提交的新任务将在执行程序关闭时被拒绝 ，并且当执行程序对最大线程和工作队列容量使用有限边界并且饱和时。 在任一情况下， execute方法调用RejectedExecutionHandler.rejectedExecution(Runnable, ThreadPoolExecutor)其的方法RejectedExecutionHandler 。 提供了四个预定义的处理程序策略：

1. 在默认ThreadPoolExecutor.AbortPolicy，处理程序会引发运行RejectedExecutionException后排斥反应。

2. 在ThreadPoolExecutor.CallerRunsPolicy中，调用execute本身的线程运行任务。这提供了一个简单的反馈控制机制，将降低新任务提交的速度。

3. 在ThreadPoolExecutor.DiscardPolicy中 ，简单地删除无法执行的任务。

4. 在ThreadPoolExecutor.DiscardOldestPolicy中，如果执行程序没有关闭，则工作队列头部的任务被删除，然后重试执行（可能会再次失败，导致重复）。

可以定义和使用其他类型的RejectedExecutionHandler类。 这样做需要特别注意，特别是当策略被设计为仅在特定容量或排队策略下工作时。