四种线程池 FixedThreadPool SingleThreadPool CachedThreadPool ScheduledThreadPool 学习整理

四种线程池 FixedThreadPool  SingleThreadPool CachedThreadPool ScheduledThreadPool 学习整理

基于阿里开发文档 并发处理  进行初步了解及整理文档：

文档原文： 【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样 的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

1）FixedThreadPool 和 SingleThreadPool: 允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

2）CachedThreadPool 和 ScheduledThreadPool: 允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

 

四种线程池：

FixedThreadPool  是可重用固定线程数的线程池

创建方法

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

corePoolSize和maximumPoolSize都设置为创建FixedThreadPool指定的参数nThreads，即FixedThreadPool只有核心线程，且数量固定，没有非核心线程。keepAliveTime设置为0L，代表多余的线程会被立即终止。因为不会产生多余的线程，所以keepAliveTime是无效的参数；任务队列采用了无界的阻塞队列LinkedBlockingQueue（容量默认为Integer.MAX_VALUE）。

当执行execute方法时，若当前运行的线程未达到核心线程数corePoolSize，就创建核心线程处理任务；否则，就把任务添加到LinkedBlockingQueue中。

原文链接：https://blog.csdn.net/qq_36299025/article/details/89490636

 

SingleThreadPool 是使用单个工作线程的线程池

创建方法

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

corePoolSize和maximumPoolSize都是1，即SingleThreadPool只有一个核心线程。其他参数都和FixedThreadPool一样。

execute方法执行

执行execute方法时，若当前运行的线程数未达到核心线程数（没有正在运行的线程），就创建一个新线程来处理任务；如果当前有运行的线程，就把任务添加到阻塞队列LinkedBlockingQueue。SingleThreadPool能够确保所有的任务都在一个线程中按照顺序逐一执行。

原文链接：https://blog.csdn.net/qq_36299025/article/details/89491035

 

CachedThreadPool 是一个根据需要创建线程的线程池

创建方法

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

corePoolSize = 0，maximumPoolSize设置为Integer.MAX_VALUE，代表没有核心线程，非核心线程是无界的；keepAliveTime = 60L，空闲线程等待新任务的最长时间是60s；用了阻塞队列SynchronousQueue,是一个不存储元素的阻塞队列，每一个插入操作必须等待另一个线程的移除操作，同理一个移除操作也得等待另一个线程的插入操作完成；

execute方法执行

执行execute方法时，首先会先执行SynchronousQueue的offer方法提交任务，并查询线程池中是否有空闲线程来执行SynchronousQueue的poll方法来移除任务。如果有，则配对成功，将任务交给这个空闲线程。否则，配对失败，创建新的线程去处理任务；当线程池中的线程空闲时，会执行SynchronousQueue的poll方法等待执行SynchronousQueue中新提交的任务。若超过60s依然没有任务提交到SynchronousQueue，这个空闲线程就会终止；因为maximumPoolSize是无界的，所以提交任务的速度 > 线程池中线程处理任务的速度就要不断创建新线程；每次提交任务，都会立即有线程去处理，因此CachedThreadPool适用于处理大量、耗时少的任务。

原文链接：https://blog.csdn.net/qq_36299025/article/details/89490858

 

 

ScheduledThreadPool 是一个能实现定时、周期性任务的线程池。

创建方法

 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

这里创建了ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，主要用于给定 延时之后的运行任务或定期处理任务。ScheduledThreadPoolExecutor的构造方法如下：

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

ScheduledThreadPoolExecutor构造方法中最终调用的是父类ThreadPoolExecutor的构造方法；corePoolSize是传递进来的固定数值，maximumPoolSize的值是Integer.MAX_VALUE；DelayedWorkQueue是无界的，因此maximumPoolSize是无效的。

execute方法执行

当执行ScheduledThreadPoolExecutor的scheduleAtFixedRate或scheduleWithFixedDelay方法，会向DelayedWorkQueue添加一个实现RunnableScheduledFuture接口的任务包装类ScheduledFutureTask，并检查运行的线程是否达到核心线程数corePoolSize。
如果没有就新建线程，并启动。但并非立即执行任务，而是去DelayedWorkQueue中取任务包装类ScheduledFutureTask，然后再去执行任务；
如果运行的线程达到了corePoolSize，就把任务添加到任务队列DelayedWorkQueue中；DelayedWorkQueue会将任务排序，先执行的任务放在队列的前面。
任务执行完后，ScheduledFutureTask中的变量time改为下次要执行的时间，并放回到DelayedWorkQueue中。

 

原文链接：https://blog.csdn.net/qq_36299025/article/details/89491384