Executors四大线程池工厂方法的使用

Myth丶恋晨 2022-12-15 03:53 173阅读 0赞

# Executors工厂方法的使用 #

Executors提供了四个创建线程池的工厂方法，分别是：

*  Executors.newSingleThreadExecutor()
 *  Executors.newFixedThreadPool()
 *  Executors.newCachedThreadPool()
 *  Executors.newScheduledThreadPool()

## newSingleThreadExecutor() ##

newSingleThreadExecutor()只会启用一个核心线程干活，使用无界队列存放所有的任务。

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    import java.util.stream.IntStream;
    
    import lombok.extern.slf4j.Slf4j;
    
    /** * newSingleThreadExecutor的使用 * 只有一个线程干活 */
    @Slf4j
    public class SingleThreadPoolDemo { 
    
        public static void main(String[] args) { 
    
            ExecutorService executorService = Executors.newSingleThreadExecutor();
    
            IntStream.rangeClosed(1, 3).forEach(i -> executorService.submit(() -> { 
                log.info("task begin ...");
                try { 
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                log.info("task end .");
            }));
            executorService.shutdown();
        }
    }

运行结果如下：

2020-10-14 10:42:54,971  INFO [pool-1-thread-1] (SingleThreadPoolDemo.java:18) - task begin ...
    2020-10-14 10:42:57,973  INFO [pool-1-thread-1] (SingleThreadPoolDemo.java:24) - task end .
    2020-10-14 10:42:57,973  INFO [pool-1-thread-1] (SingleThreadPoolDemo.java:18) - task begin ...
    2020-10-14 10:43:00,975  INFO [pool-1-thread-1] (SingleThreadPoolDemo.java:24) - task end .
    2020-10-14 10:43:00,975  INFO [pool-1-thread-1] (SingleThreadPoolDemo.java:18) - task begin ...
    2020-10-14 10:43:03,975  INFO [pool-1-thread-1] (SingleThreadPoolDemo.java:24) - task end .

newSingleThreadExecutor()的源码如下，可以看出只有一个核心线程，使用阻塞队列的是无界队列。

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

这里有个疑问，一个线程还搞啥线程池，直接new Thread()岂不是更简单明了？

下面通过一个例子来说明newSingleThreadExecutor()线程池与new Thread()的区别：

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    import java.util.stream.IntStream;
    
    /** * newSingleThreadExecutor的使用 * 只有一个线程干活 */
    @Slf4j
    public class SingleThreadPoolDemo2 { 
    
        public static void main(String[] args) { 
    
            ExecutorService executorService = Executors.newSingleThreadExecutor();
    
            IntStream.rangeClosed(1, 5).forEach(i -> executorService.submit(() -> { 
                log.info("task{} begin ...", i);
                if (i == 3) { 
                    int j = 10 / 0;
                }
                log.info("task{} end .", i);
            }));
            executorService.shutdown();
        }
    }

运行结果如下：

2020-10-15 14:19:52,309  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:22) - task1 begin ...
    2020-10-15 14:19:52,312  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:26) - task1 end .
    2020-10-15 14:19:52,314  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:22) - task2 begin ...
    2020-10-15 14:19:52,314  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:26) - task2 end .
    2020-10-15 14:19:52,314  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:22) - task3 begin ...
    2020-10-15 14:19:52,315  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:22) - task4 begin ...
    2020-10-15 14:19:52,315  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:26) - task4 end .
    2020-10-15 14:19:52,315  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:22) - task5 begin ...
    2020-10-15 14:19:52,315  INFO [pool-1-thread-1] (SingleThreadPoolDemo2.java:26) - task5 end .

自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池会将异常捕获存放到FutureTask中，然后继续执行下一个任务，当调用Future.get()时才会抛出异常，不会影响下一个任务的执行。

## newFixedThreadPool() ##

newSingleThreadExecutor()使用固定个数的核心线程干活，使用无界队列存放所有的任务。

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    import java.util.stream.IntStream;
    
    /** * newFixedThreadPool的使用 * 定长，指定多少个，就启动多少个线程干活，无界队列存储所有的任务 */
    @Slf4j
    public class FixThreadPoolDemo { 
    
        public static void main(String[] args) { 
            ExecutorService executorService = Executors.newFixedThreadPool(3);
    
            IntStream.rangeClosed(1, 10).forEach(i -> executorService.submit(() -> { 
                log.info("task{} begin ...", i);
                try { 
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                log.info("task{} end .", i);
            }));
            executorService.shutdown();
        }
    }

运行结果如下：

2020-10-14 11:03:41,065  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:17) - task3 begin ...
    2020-10-14 11:03:41,065  INFO [pool-1-thread-1] (FixThreadPoolDemo.java:17) - task1 begin ...
    2020-10-14 11:03:41,065  INFO [pool-1-thread-2] (FixThreadPoolDemo.java:17) - task2 begin ...
    2020-10-14 11:03:44,067  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:23) - task3 end .
    2020-10-14 11:03:44,067  INFO [pool-1-thread-1] (FixThreadPoolDemo.java:23) - task1 end .
    2020-10-14 11:03:44,067  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:17) - task4 begin ...
    2020-10-14 11:03:44,067  INFO [pool-1-thread-1] (FixThreadPoolDemo.java:17) - task5 begin ...
    2020-10-14 11:03:44,068  INFO [pool-1-thread-2] (FixThreadPoolDemo.java:23) - task2 end .
    2020-10-14 11:03:44,068  INFO [pool-1-thread-2] (FixThreadPoolDemo.java:17) - task6 begin ...
    2020-10-14 11:03:47,067  INFO [pool-1-thread-1] (FixThreadPoolDemo.java:23) - task5 end .
    2020-10-14 11:03:47,067  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:23) - task4 end .
    2020-10-14 11:03:47,067  INFO [pool-1-thread-1] (FixThreadPoolDemo.java:17) - task7 begin ...
    2020-10-14 11:03:47,067  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:17) - task8 begin ...
    2020-10-14 11:03:47,068  INFO [pool-1-thread-2] (FixThreadPoolDemo.java:23) - task6 end .
    2020-10-14 11:03:47,068  INFO [pool-1-thread-2] (FixThreadPoolDemo.java:17) - task9 begin ...
    2020-10-14 11:03:50,067  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:23) - task8 end .
    2020-10-14 11:03:50,068  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:17) - task10 begin ...
    2020-10-14 11:03:50,068  INFO [pool-1-thread-2] (FixThreadPoolDemo.java:23) - task9 end .
    2020-10-14 11:03:50,067  INFO [pool-1-thread-1] (FixThreadPoolDemo.java:23) - task7 end .
    2020-10-14 11:03:53,068  INFO [pool-1-thread-3] (FixThreadPoolDemo.java:23) - task10 end .

newSingleThreadExecutor()的源码如下，可以看出核心线程的个数为传入的 nThreads，使用的阻塞队列为无界队列：

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

## newCachedThreadPool() ##

newCachedThreadPool()中每提交一个任务，如果没有空闲的线程，就会一直创建新的线程来执行任务。

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    import java.util.stream.IntStream;
    
    /** * newCachedThreadPool的使用 * 来一个任务，如果没有空闲的线程，就会一直创建线程来执行任务 */
    @Slf4j
    public class CachedThreadPoolDemo { 
    
        public static void main(String[] args) { 
            ExecutorService executorService = Executors.newCachedThreadPool();
    
            IntStream.rangeClosed(1, 10).forEach(i -> executorService.submit(() -> { 
                log.info("task{} begin ...", i);
                try { 
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                log.info("task{} end .", i);
            }));
            executorService.shutdown();
        }
    }

运行结果如下：

2020-10-14 11:11:06,416  INFO [pool-1-thread-1] (CachedThreadPoolDemo.java:20) - task1 begin ...
    2020-10-14 11:11:06,417  INFO [pool-1-thread-9] (CachedThreadPoolDemo.java:20) - task9 begin ...
    2020-10-14 11:11:06,417  INFO [pool-1-thread-5] (CachedThreadPoolDemo.java:20) - task5 begin ...
    2020-10-14 11:11:06,417  INFO [pool-1-thread-6] (CachedThreadPoolDemo.java:20) - task6 begin ...
    2020-10-14 11:11:06,417  INFO [pool-1-thread-7] (CachedThreadPoolDemo.java:20) - task7 begin ...
    2020-10-14 11:11:06,417  INFO [pool-1-thread-8] (CachedThreadPoolDemo.java:20) - task8 begin ...
    2020-10-14 11:11:06,417  INFO [pool-1-thread-3] (CachedThreadPoolDemo.java:20) - task3 begin ...
    2020-10-14 11:11:06,417  INFO [pool-1-thread-10] (CachedThreadPoolDemo.java:20) - task10 begin ...
    2020-10-14 11:11:06,416  INFO [pool-1-thread-4] (CachedThreadPoolDemo.java:20) - task4 begin ...
    2020-10-14 11:11:06,416  INFO [pool-1-thread-2] (CachedThreadPoolDemo.java:20) - task2 begin ...
    2020-10-14 11:11:09,418  INFO [pool-1-thread-1] (CachedThreadPoolDemo.java:26) - task1 end .
    2020-10-14 11:11:09,418  INFO [pool-1-thread-9] (CachedThreadPoolDemo.java:26) - task9 end .
    2020-10-14 11:11:09,419  INFO [pool-1-thread-5] (CachedThreadPoolDemo.java:26) - task5 end .
    2020-10-14 11:11:09,420  INFO [pool-1-thread-7] (CachedThreadPoolDemo.java:26) - task7 end .
    2020-10-14 11:11:09,420  INFO [pool-1-thread-10] (CachedThreadPoolDemo.java:26) - task10 end .
    2020-10-14 11:11:09,420  INFO [pool-1-thread-3] (CachedThreadPoolDemo.java:26) - task3 end .
    2020-10-14 11:11:09,420  INFO [pool-1-thread-4] (CachedThreadPoolDemo.java:26) - task4 end .
    2020-10-14 11:11:09,420  INFO [pool-1-thread-6] (CachedThreadPoolDemo.java:26) - task6 end .
    2020-10-14 11:11:09,420  INFO [pool-1-thread-2] (CachedThreadPoolDemo.java:26) - task2 end .
    2020-10-14 11:11:09,420  INFO [pool-1-thread-8] (CachedThreadPoolDemo.java:26) - task8 end .

先来理解下一个特殊的阻塞队列SynchronousQueue：

package com.morris.concurrent.threadpool.threadpoolexecutor.blockqueue;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.SynchronousQueue;
    import java.util.concurrent.TimeUnit;
    
    /** * SynchronousQueue的使用 */
    @Slf4j
    public class SynchronousQueueDemo { 
    
        public static void main(String[] args) { 
            SynchronousQueue synchronousQueue = new SynchronousQueue();
    
            Thread produceThread = new Thread(() -> { 
                log.info("begin...");
                try { 
                    TimeUnit.SECONDS.sleep(10);
                    synchronousQueue.put("ooxx"); // 阻塞
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                log.info("end.");
            }, "produceThread");
            produceThread.start();
    
    
            Thread consumerThread = new Thread(() -> { 
                log.info("begin...");
                try { 
                    log.info("get message:{}", synchronousQueue.take()); // 阻塞
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                log.info("end.");
            }, "consumerThread");
            consumerThread.start();
        }
    }

运行结果如下：

2020-10-14 14:49:13,158  INFO [produceThread] (SynchronousQueueDemo.java:18) - begin...
    2020-10-14 14:49:13,158  INFO [consumerThread] (SynchronousQueueDemo.java:31) - begin...
    2020-10-14 14:49:23,160  INFO [produceThread] (SynchronousQueueDemo.java:25) - end.
    2020-10-14 14:49:23,161  INFO [consumerThread] (SynchronousQueueDemo.java:33) - get message:ooxx
    2020-10-14 14:49:23,161  INFO [consumerThread] (SynchronousQueueDemo.java:37) - end.

从运行结果可以发现，一个线程调用take()方法时如果阻塞队列中没有另一个线程来调用put方法时就会一直被阻塞，可以认为这是一种线程与线程间一对一传递消息的模型。同样，如果一个线程调用了put()方法生产了数据放入阻塞队列中，如果没有另一个线程来调用take()方法从阻塞队列中消费数据，put就会一直被阻塞直到有线程调用take()方法。

newCachedThreadPool()的源码如下：

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

newCachedThreadPool()线程池中没有核心线程数，当一个任务提交过来时，如果有线程池中没有空闲的线程，而SynchronousQueue是无法存放数据的，所以会创建一个新的线程来执行这个任务，当线程池中的线程60s内还没有获取到任务就会自动销毁。

适用场景：这种线程池比较灵活，适用于消费者的能力和生产者的能力相等，也就是需要异步执行并且执行时间短的任务，不适用于那种生产者生产数据非常快，消费消费数据非常慢，甚至有大量的IO阻塞的任务，如果消费者不能及时消费数据，那么就会不停的创建线程，最后会导致OOM异常。

## newScheduledThreadPool() ##

newScheduledThreadPool()可以让提交的任务延迟执行。

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    import java.util.stream.IntStream;
    
    /** * ScheduledThreadPool的使用 */
    @Slf4j
    public class ScheduledThreadPoolDemo { 
    
        public static void main(String[] args) { 
            ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
    
            IntStream.rangeClosed(1, 5).forEach(i -> { 
                log.info("submit task{}", i);
                scheduledExecutorService.schedule(() -> { 
                    log.info("execute task{}", i);
                }, 3L, TimeUnit.SECONDS);
            });
            scheduledExecutorService.shutdown();
        }
    }

运行结果如下：

2020-10-15 11:03:37,110  INFO [main] (ScheduledThreadPoolDemo.java:20) - submit task1
    2020-10-15 11:03:37,114  INFO [main] (ScheduledThreadPoolDemo.java:20) - submit task2
    2020-10-15 11:03:37,115  INFO [main] (ScheduledThreadPoolDemo.java:20) - submit task3
    2020-10-15 11:03:37,115  INFO [main] (ScheduledThreadPoolDemo.java:20) - submit task4
    2020-10-15 11:03:37,116  INFO [main] (ScheduledThreadPoolDemo.java:20) - submit task5
    2020-10-15 11:03:40,115  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo.java:22) - execute task2
    2020-10-15 11:03:40,115  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo.java:22) - execute task1
    2020-10-15 11:03:40,115  INFO [pool-1-thread-3] (ScheduledThreadPoolDemo.java:22) - execute task3
    2020-10-15 11:03:40,117  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo.java:22) - execute task4
    2020-10-15 11:03:40,117  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo.java:22) - execute task5

从运行结果的执行时间上可以看出，提交任务后，等待3s，任务才会被执行。

如果我想任务每隔3s钟执行一次，该怎么实现呢？

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /** * ScheduledThreadPool的使用 * 每隔3秒执行一次任务 */
    @Slf4j
    public class ScheduledThreadPoolDemo2 { 
    
        private static ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
    
        public static void main(String[] args) { 
            execute();
        }
    
        private static void execute() { 
            scheduledExecutorService.schedule(() -> { 
                log.info("execute task");
                execute();
            }, 3, TimeUnit.SECONDS);
    
        }
    }

咋一看上面的代码，好像是一个递归的死循环，会因为方法的调用次数过多，导致线程的虚拟机栈的栈帧过多，从而导致OOM异常，其实`execute()`的是由线程池中的线程异步执行，所以不会OOM，从运行结果也可以发现任务会由不同的线程运行。

运行结果如下：

2020-10-15 11:23:21,301  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo2.java:23) - execute task
    2020-10-15 11:23:24,305  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo2.java:23) - execute task
    2020-10-15 11:23:27,307  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo2.java:23) - execute task
    2020-10-15 11:23:30,308  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo2.java:23) - execute task
    ... ...

当然newScheduledThreadPool()已经封装了一个现成的方法scheduleWithFixedDelay来实现上面类似递归的功能。

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /** * ScheduledThreadPool的使用 * 每隔3秒执行一次任务之scheduleWithFixedDelay */
    @Slf4j
    public class ScheduledThreadPoolDemo3 { 
    
        private static ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
    
        public static void main(String[] args) { 
            scheduledExecutorService.scheduleWithFixedDelay(() -> { 
                log.info("execute task");
                try { 
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }, 3,5, TimeUnit.SECONDS);
        }
    }

运行结果如下：

2020-10-15 11:36:55,733  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo3.java:20) - execute task
    2020-10-15 11:37:10,736  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo3.java:20) - execute task
    2020-10-15 11:37:25,739  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo3.java:20) - execute task
    2020-10-15 11:37:40,739  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo3.java:20) - execute task
    ... ...

上面的代码也会有一个问题：假如任务从`00:00:00`时间点开始执行，任务执行需要花费10s，那么下一个任务在`00:00:10`才会被提交到线程池中，真正的执行时间点在`00:00:13`，而不是每个3s的时间点`00:00:03`。

newScheduledThreadPool()提供了一个固定时间间隔执行任务的方法：

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /** * ScheduledThreadPool的使用 * 每隔3秒执行一次任务之scheduleAtFixedRate */
    @Slf4j
    public class ScheduledThreadPoolDemo4 { 
    
        private static ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
    
        public static void main(String[] args) { 
            scheduledExecutorService.scheduleAtFixedRate(() -> { 
                log.info("execute task");
                try { 
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }, 3, 5, TimeUnit.SECONDS);
        }
    }

运行结果如下：

2020-10-15 13:46:50,591  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo4.java:20) - execute task
    2020-10-15 13:47:00,593  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo4.java:20) - execute task
    2020-10-15 13:47:10,596  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo4.java:20) - execute task
    2020-10-15 13:47:20,596  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo4.java:20) - execute task
    ... ...

从运行结果发现，任务执行的时间间隔为10s，并不是参数设置的5s，也就说当执行任务的时间大于我们指定的间隔时间时，它并不会在指定间隔时开辟一个新的线程并发执行这个任务，而是等待该线程执行完毕。

scheduleAtFixedRate()的源码注释上面也对此方法的使用进行了说明：

/** * Creates and executes a periodic action that becomes enabled first * after the given initial delay, and subsequently with the given * period; that is executions will commence after * {@code initialDelay} then {@code initialDelay+period}, then * {@code initialDelay + 2 * period}, and so on. * If any execution of the task * encounters an exception, subsequent executions are suppressed. * Otherwise, the task will only terminate via cancellation or * termination of the executor. If any execution of this task * takes longer than its period, then subsequent executions * may start late, but will not concurrently execute. ......

注释中还提到了如果任务发生了异常，后面的任务就不会执行了。

package com.morris.concurrent.threadpool.threadpoolexecutor.executors;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /** * ScheduledThreadPool的使用 * 每隔3秒执行一次任务之异常，任务发生异常后，后面的任务就不会执行了 */
    @Slf4j
    public class ScheduledThreadPoolDemo5 { 
    
        private static ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
    
        private static int i = 0;
    
        public static void main(String[] args) { 
            scheduledExecutorService.scheduleAtFixedRate(() -> { 
                log.info("execute task");
                if(i == 3) { 
                    int j = i / 0;
                }
                i++;
            }, 3, 5, TimeUnit.SECONDS);
        }
    }

运行结果如下，只执行4次就不会执行了，但是进程还在，因为还有活跃的非守护线程，异常不会抛出来。

2020-10-15 14:11:14,201  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo5.java:22) - execute task
    2020-10-15 14:11:19,202  INFO [pool-1-thread-1] (ScheduledThreadPoolDemo5.java:22) - execute task
    2020-10-15 14:11:24,202  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo5.java:22) - execute task
    2020-10-15 14:11:29,202  INFO [pool-1-thread-2] (ScheduledThreadPoolDemo5.java:22) - execute task

最后再来看一下newScheduledThreadPool()的源码：

java.util.concurrent.Executors\#newScheduledThreadPool(int)

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

java.util.concurrent.ScheduledThreadPoolExecutor\#ScheduledThreadPoolExecutor(int)

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

newScheduledThreadPool()不像其他3个线程池直接创建ThreadPoolExecutor对象，而是创建一个继承了ThreadPoolExecutor的ScheduledThreadPoolExecutor对象，另外还使用了带延迟的阻塞队列DelayedWorkQueue。

## 总结 ##

最后用一个表格来总结本文的内容：

<table> 
 <thead> 
  <tr> 
   <th>线程池</th> 
   <th>创建的对象</th> 
   <th>核心线程数</th> 
   <th>最大线程数据</th> 
   <th>超时时间</th> 
   <th>超时时间单位</th> 
   <th>阻塞队列</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>newSingleThreadExecutor</td> 
   <td>ThreadPoolExecutor</td> 
   <td>1</td> 
   <td>1</td> 
   <td>0</td> 
   <td>MILLISECONDS</td> 
   <td>LinkedBlockingQueue</td> 
  </tr> 
  <tr> 
   <td>newFixedThreadPool()</td> 
   <td>ThreadPoolExecutor</td> 
   <td>n</td> 
   <td>n</td> 
   <td>0</td> 
   <td>MILLISECONDS</td> 
   <td>LinkedBlockingQueue</td> 
  </tr> 
  <tr> 
   <td>newCachedThreadPool()</td> 
   <td>ThreadPoolExecutor</td> 
   <td>0</td> 
   <td>Integer.MAX_VALUE</td> 
   <td>60</td> 
   <td>SECONDS</td> 
   <td>SynchronousQueue</td> 
  </tr> 
  <tr> 
   <td>newScheduledThreadPool()</td> 
   <td>ScheduledThreadPoolExecutor</td> 
   <td>n</td> 
   <td>Integer.MAX_VALUE</td> 
   <td>0</td> 
   <td>NANOSECONDS</td> 
   <td>DelayedWorkQueue</td> 
  </tr> 
 </tbody> 
</table>