J.U.C Review - 线程池原理/源码解析

文章目录

为什么要使用线程池
ThreadPoolExecutor
- 构造方法解析
- 常见的阻塞队列实现及其特性
- 阻塞队列在实际应用中的适用场景分析
- 自定义ThreadFactory和RejectedExecutionHandler
- - 实际使用中的示例与代码片段
线程池的状态
线程池的任务处理流程
线程复用的实现
四种常见的线程池
- `newCachedThreadPool`
- `newFixedThreadPool`
- `newSingleThreadExecutor`
- `newScheduledThreadPool`
小结

在这里插入图片描述

为什么要使用线程池

使用线程池的主要原因有：

资源优化：创建和销毁线程需要消耗系统资源，使用线程池可以复用已经创建的线程，减少开销。
控制并发：可以控制同时运行的线程数量，避免因过多并发导致系统资源耗尽。
统一管理：线程池可以对线程进行统一管理，简化并发编程。

ThreadPoolExecutor

Java中的线程池由Executor接口定义，ThreadPoolExecutor是其最常见的实现。

ThreadPoolExecutor的构造方法涉及以下参数：

构造方法解析

ThreadPoolExecutor有四个构造方法，涉及5到7个参数，其中最重要的5个参数是：

// 五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

// 六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

// 六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)

// 七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

corePoolSize：核心线程数，核心线程即使空闲也不会被销毁。
maximumPoolSize：线程池最大线程数，包含核心和非核心线程。
keepAliveTime：非核心线程的闲置超时时间，超过该时间则被销毁。如果设置allowCoreThreadTimeOut(true)，则会也作用于核心线程
unit：时间单位，决定keepAliveTime的时间单位。
workQueue：阻塞队列，用于存储等待执行的任务。

常用的几个阻塞队列：
1. LinkedBlockingQueue
  
  链式阻塞队列，底层数据结构是链表，默认大小是Integer.MAX_VALUE，也可以指定大小。
2. ArrayBlockingQueue
  
  数组阻塞队列，底层数据结构是数组，需要指定队列的大小。
3. SynchronousQueue
  
  同步队列，内部容量为0，每个put操作必须等待一个take操作，反之亦然。
4. DelayQueue
  
  延迟队列，该队列中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。

另外，两个可选参数是：

threadFactory：创建线程的工厂，允许自定义线程的创建方式。

创建线程的工厂，用于批量创建线程，统一在创建线程时设置一些参数，如是否守护线程、线程的优先级等。如果不指定，会新建一个默认的线程工厂。

static class DefaultThreadFactory implements ThreadFactory {
    // 省略属性
    // 构造函数
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
        Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
            poolNumber.getAndIncrement() +
            "-thread-";
    }
    
    // 省略
}

handler：拒绝策略，当任务无法被处理时执行。

拒绝处理策略，线程数量大于最大线程数就会采用拒绝处理策略，四种拒绝处理的策略为：
1. ThreadPoolExecutor.AbortPolicy：默认拒绝处理策略，丢弃任务并抛出RejectedExecutionException异常。
2. ThreadPoolExecutor.DiscardPolicy：丢弃新来的任务，但是不抛出异常。
3. ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列头部（最旧的）的任务，然后重新尝试执行程序（如果再次失败，重复此过程）。
4. ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

常见的阻塞队列实现及其特性

Java的java.util.concurrent包中提供了几种常见的阻塞队列实现：

ArrayBlockingQueue：
- 特点：基于数组的有界阻塞队列，容量固定，使用一个锁（ReentrantLock）控制所有操作。
- 适用场景：适合生产者和消费者数量较为均衡的场景，且队列容量需要明确限制的情况下使用。
LinkedBlockingQueue：
- 特点：基于链表的阻塞队列，可以是有界的（指定容量）或者无界的（容量为Integer.MAX_VALUE），入队和出队操作分别使用不同的锁，因此并发性能较好。
- 适用场景：适用于生产者和消费者不均衡，或者希望队列可以动态扩展容量的场景。
PriorityBlockingQueue：
- 特点：基于优先级的无界阻塞队列，元素会按照自然顺序或者指定的比较器顺序排列。
- 适用场景：适合需要按照优先级处理任务的场景，比如任务调度系统。
DelayQueue：
- 特点：无界阻塞队列，元素在放入队列时会指定一个延迟时间，只有延迟时间到达后才能被取出。
- 适用场景：适用于任务延迟执行的场景，比如定时任务调度。
SynchronousQueue：
- 特点：一个特殊的队列，它没有容量，每一个插入操作必须等待一个相应的移除操作，反之亦然。
- 适用场景：适合任务提交非常频繁，且任务处理时间较短的场景，典型的应用是在线程池中直接将任务从生产者交给消费者。

阻塞队列在实际应用中的适用场景分析

ArrayBlockingQueue在日志处理系统中可以用来实现一个固定大小的日志缓冲区，避免过多日志占用系统资源。
LinkedBlockingQueue则适合应用在任务处理较多、峰值流量不可预估的场景，比如处理Web请求。
PriorityBlockingQueue可以用于任务调度器或工作流引擎中，确保高优先级的任务先被处理。
DelayQueue常用于实现延时任务或定时任务，比如在订单系统中处理延时支付。
SynchronousQueue则在高并发环境下非常有用，比如在高效的消息传递系统中作为核心机制。

自定义ThreadFactory和RejectedExecutionHandler

自定义ThreadFactory和RejectedExecutionHandler可以增强线程池的功能。

ThreadFactory：

概念：ThreadFactory接口提供了一种创建新线程的机制。自定义的ThreadFactory可以用于设置线程名称、优先级、是否守护线程等属性。
使用场景：当你希望每个线程在创建时都具有特定的属性，比如命名为特定前缀以便调试，或者为线程设置不同的优先级以处理不同的任务。

public class CustomThreadFactory implements ThreadFactory {
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    public CustomThreadFactory(String namePrefix) {
        this.namePrefix = namePrefix;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, namePrefix + "-thread-" + threadNumber.getAndIncrement());
        t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

RejectedExecutionHandler：
- 概念：RejectedExecutionHandler接口定义了当线程池无法处理新的任务时所采取的策略。内置的策略包括AbortPolicy（抛出异常）、DiscardPolicy（丢弃任务）、DiscardOldestPolicy（丢弃最旧的任务）以及CallerRunsPolicy（由调用线程执行任务）。
- 使用场景：当任务提交量超过线程池的处理能力时，使用自定义的拒绝策略可以实现更细致的控制，比如将任务移至另一个线程池，或者记录日志以备后续处理。
```
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // Log the rejected task
        System.out.println("Task rejected: " + r.toString());
        // Implement custom handling logic here
    }
}
```

实际使用中的示例与代码片段

一个使用自定义ThreadFactory和RejectedExecutionHandler创建线程池的示例：

ThreadFactory threadFactory = new CustomThreadFactory("MyPool");
RejectedExecutionHandler rejectionHandler = new CustomRejectedExecutionHandler();
ThreadPoolExecutor executor = new ThreadPoolExecutor(
        2, 4, 10, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(2), threadFactory, rejectionHandler);

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println(Thread.currentThread().getName() + " is executing");
    });
}

executor.shutdown();

CustomThreadFactory设置了线程的名称前缀，而CustomRejectedExecutionHandler处理被拒绝的任务。

线程池的状态

ThreadPoolExecutor通过ctl变量（一个AtomicInteger类型）管理线程池的状态。状态包括：

RUNNING：正常运行状态，可以接受新任务。
SHUTDOWN：调用shutdown()后，不能接受新任务，但会执行队列中的任务。
STOP：调用shutdownNow()后，立即停止所有任务，丢弃未处理的任务。
TIDYING：所有任务已终止且线程数为0时进入此状态。
TERMINATED：执行terminated()后进入终止状态。

线程池本身有一个调度线程，这个线程就是用于管理布控整个线程池里的各种任务和事务，例如创建线程、销毁线程、任务队列管理、线程队列管理等等。

故线程池也有自己的状态。ThreadPoolExecutor类中使用了一些final int常量变量来表示线程池的状态，分别为RUNNING、SHUTDOWN、STOP、TIDYING 、TERMINATED。

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

线程池创建后处于RUNNING状态。
调用shutdown()方法后处于SHUTDOWN状态，线程池不能接受新的任务，清除一些空闲worker,不会等待阻塞队列的任务完成。
调用shutdownNow()方法后处于STOP状态，线程池不能接受新的任务，中断所有线程，阻塞队列中没有被执行的任务全部丢弃。此时，poolsize=0,阻塞队列的size也为0。
当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。接着会执行terminated()函数。

ThreadPoolExecutor中有一个控制状态的属性叫ctl，它是一个AtomicInteger类型的变量。线程池状态就是通过AtomicInteger类型的成员变量ctl来获取的。

获取的ctl值传入runStateOf方法，与~CAPACITY位与运算(CAPACITY是低29位全1的int变量)。

~CAPACITY在这里相当于掩码，用来获取ctl的高3位，表示线程池状态；而另外的低29位用于表示工作线程数
线程池处在TIDYING状态时，执行完terminated()方法之后，就会由 TIDYING -> TERMINATED，线程池被设置为TERMINATED状态。

线程池的任务处理流程

ThreadPoolExecutor的核心方法是execute，

// JDK 1.8 
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();   
    int c = ctl.get();
    // 1.当前线程数小于corePoolSize,则调用addWorker创建核心线程执行任务
    if (workerCountOf(c) < corePoolSize) {
       if (addWorker(command, true))
           return;
       c = ctl.get();
    }
    // 2.如果不小于corePoolSize，则将任务添加到workQueue队列。
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 2.1 如果isRunning返回false(状态检查)，则remove这个任务，然后执行拒绝策略。
        if (! isRunning(recheck) && remove(command))
            reject(command);
            // 2.2 线程池处于running状态，但是没有线程，则创建线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3.如果放入workQueue失败，则创建非核心线程执行任务，
    // 如果这时创建非核心线程失败(当前线程总数不小于maximumPoolSize时)，就会执行拒绝策略。
    else if (!addWorker(command, false))
         reject(command);
}

ctl.get()是获取线程池状态，用int类型表示。第二步中，入队前进行了一次isRunning判断，入队之后，又进行了一次isRunning判断。

其任务处理流程如下：

添加到核心线程：如果线程数少于corePoolSize，创建新的核心线程执行任务。
入队任务：如果线程数已达corePoolSize，将任务加入workQueue。
非核心线程处理：如果队列已满且线程数未达maximumPoolSize，创建非核心线程执行任务。
拒绝策略：如果任务无法处理，则执行拒绝策略。

为什么要二次检查线程池的状态?

在多线程的环境下，线程池的状态是时刻发生变化的。很有可能刚获取线程池状态后线程池状态就改变了。判断是否将command加入workqueue是线程池之前的状态。倘若没有二次检查，万一线程池处于非RUNNING状态（在多线程环境下很有可能发生），那么command永远不会执行。

处理流程

在这里插入图片描述

线程总数量 < corePoolSize，无论线程是否空闲，都会新建一个核心线程执行任务（让核心线程数量快速达到corePoolSize，在核心线程数量 < corePoolSize时）。注意，这一步需要获得全局锁。
线程总数量 >= corePoolSize时，新来的线程任务会进入任务队列中等待，然后空闲的核心线程会依次去缓存队列中取任务来执行（体现了线程复用）。
当缓存队列满了，说明这个时候任务已经多到爆棚，需要一些“临时工”来执行这些任务了。于是会创建非核心线程去执行这个任务。注意，这一步需要获得全局锁。
缓存队列满了，且总线程数达到了maximumPoolSize，则会采取上面提到的拒绝策略进行处理。

线程复用的实现

线程池通过Worker类实现线程的复用。Worker类是Runnable的实现，在被创建时绑定一个线程。这个Worker对象会不断从阻塞队列中取任务并执行，直到队列为空或线程池被关闭，从而实现线程的复用。

addWorker方法：用于添加新的Worker对象（即新的线程）。
runWorker方法：Worker对象在启动后会执行这个方法，循环获取并执行任务，直到任务队列为空。

// ThreadPoolExecutor.addWorker方法源码上半部分
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                // 1.如果core是ture,证明需要创建的线程为核心线程，则先判断当前线程是否大于核心线程
                // 如果core是false,证明需要创建的是非核心线程，则先判断当前线程数是否大于总线程数
                // 如果不小于，则返回false
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

上半部分主要是判断线程数量是否超出阈值，超过了就返回false

我们继续看下半部分:

    // ThreadPoolExecutor.addWorker方法源码下半部分
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 1.创建一个worker对象
        w = new Worker(firstTask);
        // 2.实例化一个Thread对象
        final Thread t = w.thread;
        if (t != null) {
            // 3.线程池全局锁
            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());

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                // 4.启动这个线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

创建worker对象，并初始化一个Thread对象，然后启动这个线程对象。

我们接着看看Worker类，仅展示部分源码：

// Worker类部分源码
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
    final Thread thread;
    Runnable firstTask;
    
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    
    public void run() {
            runWorker(this);
    }
    //其余代码略...
}

Worker类实现了Runnable接口，所以Worker也是一个线程任务。在构造方法中，创建了一个线程，线程的任务就是自己。故addWorker方法调用addWorker方法源码下半部分中的第4步t.start，会触发Worker类的run方法被JVM调用。

我们再看看runWorker的逻辑：

// Worker.runWorker方法源代码
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    // 1.线程启动之后，通过unlock方法释放锁
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 2.Worker执行firstTask或从workQueue中获取任务，如果getTask方法不返回null,循环不退出
        while (task != null || (task = getTask()) != null) {
            // 2.1进行加锁操作，保证thread不被其他线程中断（除非线程池被中断）
            w.lock();
            // If pool is stopping, ensure thread is interrupted;
            // if not, ensure thread is not interrupted.  This
            // requires a recheck in second case to deal with
            // shutdownNow race while clearing interrupt
            // 2.2检查线程池状态，倘若线程池处于中断状态，当前线程将中断。 
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // 2.3执行beforeExecute 
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 2.4执行任务
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    // 2.5执行afterExecute方法 
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                // 2.6解锁操作
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

首先去执行创建这个worker时就有的任务，当执行完这个任务后，worker的生命周期并没有结束，在while循环中，worker会不断地调用getTask方法从阻塞队列中获取任务然后调用task.run()执行任务,从而达到复用线程的目的。只要getTask方法不返回null,此线程就不会退出。

当然，核心线程池中创建的线程想要拿到阻塞队列中的任务，先要判断线程池的状态，如果STOP或者TERMINATED，返回null。

最后看看getTask方法的实现:

// Worker.getTask方法源码
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);

        // Are workers subject to culling?
        // 1.allowCoreThreadTimeOut变量默认是false,核心线程即使空闲也不会被销毁
        // 如果为true,核心线程在keepAliveTime内仍空闲则会被销毁。 
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
		// 2.如果运行线程数超过了最大线程数，但是缓存队列已经空了，这时递减worker数量。 
　　　　 // 如果有设置允许线程超时或者线程数量超过了核心线程数量，
        // 并且线程在规定时间内均未poll到任务且队列为空则递减worker数量
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            // 3.如果timed为true(想想哪些情况下timed为true),则会调用workQueue的poll方法获取任务.
            // 超时时间是keepAliveTime。如果超过keepAliveTime时长，
            // poll返回了null，上边提到的while循序就会退出，线程也就执行完了。
            // 如果timed为false（allowCoreThreadTimeOut为false
            // 且wc > corePoolSize为false），则会调用workQueue的take方法阻塞在当前。
            // 队列中有任务加入时，线程被唤醒，take方法返回任务，并执行。
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

核心线程的会一直卡在workQueue.take方法，被阻塞并挂起，不会占用CPU资源，直到拿到Runnable 然后返回（当然如果allowCoreThreadTimeOut设置为true,那么核心线程就会去调用poll方法，因为poll可能会返回null,所以这时候核心线程满足超时条件也会被销毁）。

非核心线程会workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) ，如果超时还没有拿到，下一次循环判断compareAndDecrementWorkerCount就会返回null,Worker对象的run()方法循环体的判断为null,任务结束，然后线程被系统回收。

四种常见的线程池

Executors类提供了几种常见的线程池，方便开发者根据需求快速创建不同类型的线程池。

以下是这四种线程池的实现及其运行流程：

`newCachedThreadPool`

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

运行流程：

提交任务到线程池。
由于corePoolSize为0，不会创建核心线程。线程池最大线程数为Integer.MAX_VALUE。
任务被尝试添加到SynchronousQueue队列。
如果入队成功，任务会等待空闲线程执行。如果没有空闲线程，则创建一个非核心线程来处理任务。
如果SynchronousQueue已有任务等待，入队操作会阻塞。

适用场景：

当需要执行大量短时间的任务时，CachedThreadPool能够有效提高线程复用率，显著提高性能。
线程在60秒后回收，即使没有任务，也不会占用很多资源。

`newFixedThreadPool`

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

运行流程：

核心线程数与最大线程数相等，均为传入的nThreads。
仅创建核心线程，不能创建非核心线程。
如果核心线程空闲，任务直接交给核心线程执行；否则，任务会进入LinkedBlockingQueue等待执行。

与CachedThreadPool的区别：

FixedThreadPool只会创建核心线程，而CachedThreadPool只会创建非核心线程。
FixedThreadPool的线程不会被回收，线程会阻塞在LinkedBlockingQueue.take()，因此在没有任务时，FixedThreadPool占用的资源更多。
两者都几乎不会触发拒绝策略。FixedThreadPool因为阻塞队列很大（最大为Integer.MAX_VALUE），而CachedThreadPool因为线程池最大容量很大（最大为Integer.MAX_VALUE）。

`newSingleThreadExecutor`

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

运行流程：

仅有一个核心线程，corePoolSize与maximumPoolSize均为1。
使用LinkedBlockingQueue（容量很大），因此不会创建非核心线程。
所有任务按照先来先执行的顺序执行。如果唯一的线程不空闲，新任务会进入队列等待执行。

适用场景：

适用于需要串行执行任务的场景，保证任务按顺序执行。

`newScheduledThreadPool`

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

ScheduledThreadPoolExecutor的构造函数：

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