Executors类中创建线程池的几种方法的分析

女爷i 2021-10-06 14:48 322阅读 0赞

# Executors类中创建线程池的几种方法的分析 #

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

1、newFixedThreadPool：创建固定大小的线程池。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

/* 函数功能：创建一个固定长度的的线程池，用于保存任务的阻塞队列为无限制长度的LinkedBlockingQueue。 线程池中的线程将会一直存在除非线程池shutdown，即线程池中的线程没有受到存活时间的限制。 */
        public static ExecutorService newFixedThreadPool(int nThreads) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }
    
        /* 函数功能：创建指定线程数的线程池，并且指定了线程工厂来生产新的线程。任务队列无界。 */
        public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>(),
                                          threadFactory);
        }

2、newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以[智能][Link 1]的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于[操作系统][Link 2]（或者说JVM）能够创建的最大线程大小。

在Executors类中此方法的代码如下：

/* 函数功能：创建一个线程池，这个线程池的corePoolSize的大小为零，maxPoolSize为Integer.MAX_VALUE. 即对于线程池，只要需要就可以创建新的线程。不过如果有空闲线程存在则就会重用此线程。 此线程池的线程都有一定的存活时间。即如果线程已经有60s没有被使用则就会被移除线程池。 */
        public static ExecutorService newCachedThreadPool() {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }
    
        //与上面的功能一样，只是指定了线程工厂。
        public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>(),
                                          threadFactory);
        }

3、newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

//创建一个单工作线程且无边界的队列的线程池。如果执行期间此线程挂掉了，则如果需要就会产生一个新线程来顺序执行任务。
        //任何时候都不会有超过一个线程是存活的
        public static ExecutorService newSingleThreadExecutor() {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }
    
        /* 函数功能：与newSingleThreadExecutor()功能一样，只是指定了线程工厂来生产新的线程。 */
        public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>(),
                                        threadFactory));
        }

4、newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

//创建一个线程池，该线程池提供延时执行任务或者是周期性执行任务的功能。
        public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
    
        public static ScheduledExecutorService newScheduledThreadPool(
                int corePoolSize, ThreadFactory threadFactory) {
            return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
        }

ScheduledThreadPoolExecutor 类中的构造函数如下：

/* 函数功能：根据指定的corePoolSize的大小来创建线程池，maxPoolSize的大小为Integer.MAX_VALUE，线程没有存活时间的限制 */
        public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue());
        }

5、newSingleThreadScheduledExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

//创建一个单线程的线程池，提供任务延时执行或周期性执行的功能。
        //如果该线程在线程池运行期间挂掉，则如果需要则会产生一个新的线程来顺序执行任务。
        public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
            return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1));
        }
    
        public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
            return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1, threadFactory));
        }

ScheduledThreadPoolExecutor 类中的构造函数如下：

/* 函数功能：根据指定的corePoolSize的大小来创建线程池，maxPoolSize的大小为Integer.MAX_VALUE. */
        public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue());
        }

## 小结 ##

以上几种创建线程池的方法我们都需要有一个大体的影响哈

[转载自此处，感谢作者总结分享！][Link 3]

[Link 1]: http://lib.csdn.net/base/aiplanning
[Link 2]: http://lib.csdn.net/base/operatingsystem
[Link 3]: http://blog.csdn.net/u010412719/article/details/52489843