并发系列（一）线程池

偏执的太偏执、 2021-11-09 06:04 433阅读 0赞

# 1.线程池思维导图预览 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70]

# 2. 知识分点 #

### 2.1 线程池的概念 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70 1]  
这里当然不是仅仅丢弃任务，线程池支持配置参数，选取不同的处理策略，下面会展示出来。

### 2.2 ThreadPoolExecutor ###

ThreadPoolExecutor的实现的顶层接口是Executor，继承了抽象类AbstractExecutorService,该抽象类实现了ExecutorService接口。

##### 2.2.1 构造函数参数 #####

*  corePoolSize（核心池大小）  
    ![在这里插入图片描述][20190805105335321.png]
 *  maximumPoolsize（最大池大小）  
    ![在这里插入图片描述][20190805105501660.png]
 *  keepAliveTime（存活时间）  
    ![在这里插入图片描述][20190805105552593.png]
 *  unit（存活时间的单位参数）
 *  workQueue（参数队列，内容较多，详情后面会有博文讲解）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70 2]  
    LinkedBlockingQueue如果设置长度，那么就是作为有界队列使用，不设置长度时，长度默认为Integer.MAX\_VALUE，视为无界队列
 *  threadFactory（创建时使用的工厂）  
    这里最常见的操作通过匿名类对线程进行命名
 *  handler（队列饱和处理策略）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70 3]  
    ThreadPoolExecutor有四个构造器,区别在于是否采用了默认的处理策略和工厂，下面介绍的java自带的四种线程池将会采用默认处理策略的构造器。  
    构造器源码如下：

//这个构造器采用了默认的工厂和处理器
     public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 Executors.defaultThreadFactory(), defaultHandler);
        }
    
    //这个构造器仅仅采用了默认的处理器
    public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 threadFactory, defaultHandler);
        }
    
    //这个构造器仅仅采用了默认的工厂
       public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  RejectedExecutionHandler handler) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 Executors.defaultThreadFactory(), handler);
        }
    
    //标准构造器，一般创建线程池均采用该构造器
     public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) {
            if (corePoolSize < 0 ||
                maximumPoolSize <= 0 ||
                maximumPoolSize < corePoolSize ||
                keepAliveTime < 0)
                throw new IllegalArgumentException();
            if (workQueue == null || threadFactory == null || handler == null)
                throw new NullPointerException();
            this.acc = System.getSecurityManager() == null ?
                    null :
                    AccessController.getContext();
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.workQueue = workQueue;
            this.keepAliveTime = unit.toNanos(keepAliveTime);
            this.threadFactory = threadFactory;
            this.handler = handler;
        }

放一个使用实例

BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(1000, true);
    		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 30, TimeUnit.SECONDS, workQueue, new ThreadFactory() {
    			@Override
    			public Thread newThread(Runnable r) {
    
    				Thread t = new Thread(r);
    				t.setName(threadName);
    				return t;
    			}
    		}, new ThreadPoolExecutor.AbortPolicy());

##### 2.2.2 其他预留方法 #####

![在这里插入图片描述][20190805111118282.png]

##### 2.2.3 线程池中线程的任务状态 #####

*  running  
    ![在这里插入图片描述][20190805111343106.png]
 *  shutdown  
    ![在这里插入图片描述][20190805111419263.png]
 *  stop  
    ![在这里插入图片描述][20190805111439252.png]
 *  titidying  
    ![在这里插入图片描述][20190805111453824.png]
 *  terminated  
    ![在这里插入图片描述][20190805111517604.png]  
    **注意：以上线程状态是不可逆转的，即只能自上而下**

### 2.3 Java自带的四种线程池 ###

java自带的四种线程池的创建都通过Executors类，四种线程都是通过静态方法进行创建

##### 2.3.1 newCachedThreadPool #####

![在这里插入图片描述][20190805111822683.png]  
源码如下：

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);
        }

##### 2.3.2 newFixedThreadPool #####

![在这里插入图片描述][20190805113613383.png]  
源码如下：

//指定核心线程池大小和最大池大小
    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.3.3 newScheduleThreadPool #####

![在这里插入图片描述][20190805114351636.png]  
源码如下：

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

可以看到这个线程池的内部实现实际上是调用了ScheduleThreadPoolExecutor的构造器，后面将会对该类进行补充说明。

##### 2.3.4 newSingleThreadExecutor #####

![在这里插入图片描述][20190805120535478.png]  
源码如下：

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

可以看到该线程池的内部实质返回的是一个FinalizableDelegatedExecutorService的对象

**注意：Java部分自带的线程池的实现方式采用了无界队列，即比如LinkedBlockingQueue没有设置大小，在部分场景下可能会造成一些严重问题，因此在使用线程池时，优先推荐自行对线程池的实现。**

**补充：**

### ScheduledThreadPoolExecutor ###

public class ScheduledThreadPoolExecutor
            extends ThreadPoolExecutor
            implements ScheduledExecutorService{}

这个线程池继承了ThreadPoolExecutor类，实现了ScheduledExecutorService接口, 其中该接口的作用和Timer/TimerTask类似，目的是解决那些需要任务重复执行的问题。而实现该接口之后，便可以进行周期性任务调度。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70]: /images/20211109/1535d4bc20fd41f3a988a9c1afcf65ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70 1]: /images/20211109/5cec4b7ba8ec45cbb92e87652641e706.png
[20190805105335321.png]: /images/20211109/3e85e14fb7eb494cbd107b2e457aab30.png
[20190805105501660.png]: /images/20211109/0de7a69eed294be4a249973d5b4d86cc.png
[20190805105552593.png]: /images/20211109/c9d033c89fda42d68a47f520aa48c824.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70 2]: /images/20211109/53da459dd33b4ad2b7d013a99155ad8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoZWxkb25fX0xlZQ_size_16_color_FFFFFF_t_70 3]: /images/20211109/2fd164ce0fc64ff294ae280cc08fe897.png
[20190805111118282.png]: /images/20211109/380a3fa52f034b308b11e0a541bb14f3.png
[20190805111343106.png]: /images/20211109/85ad0cb966b1422a833525ec816f2a79.png
[20190805111419263.png]: /images/20211109/949f7e17561b4f68a7177b6f917e7db5.png
[20190805111439252.png]: /images/20211109/7683cd67ecf847d2bf2acf4971cab5c4.png
[20190805111453824.png]: /images/20211109/027bb8db01574372a710460174a63a55.png
[20190805111517604.png]: /images/20211109/4903e22ce24444b5b795b79fd032b67d.png
[20190805111822683.png]: /images/20211109/ae8e618620744c7f997d187d04796474.png
[20190805113613383.png]: /images/20211109/d66226ab8f3c4dc0a9ce8f0759d409f8.png
[20190805114351636.png]: /images/20211109/5c1268245ee946af8842e63ae45950bf.png
[20190805120535478.png]: /images/20211109/f5285c5013634ef6bbb815419480ead9.png