线程池的好处，详解，单例（绝对好记）

淡淡的烟草味﹌ 2022-05-11 02:18 174阅读 0赞

转载请注意出处：[http://blog.csdn.net/fengye454545/article/details/79536986][http_blog.csdn.net_fengye454545_article_details_79536986]

前几天公司面试，问了很多线程池的问题，由于也是菜鸟一只本来对线程池就不太熟悉，再加上一紧张脑袋一紧，就GG了，之后可谓是深恶痛极，决定把线程池这边好好的整理一番。

# 一、线程池的好处 #

线程池是啥子，干啥使它呀，老子线程使得好好的，非得多次一举，哈哈，想必来这里看这篇文章的都对线程池有点了解。那么我来整理整理线程池的好处吧。

## **1、线程池的重用** ##

线程的创建和销毁的开销是巨大的，而通过线程池的重用大大减少了这些不必要的开销，当然既然少了这么多消费内存的开销，其线程执行速度也是突飞猛进的提升。

## 2、控制线程池的并发数 ##

初学新手可能对并发这个词语比较陌生，特此我也是结合百度百科和必生所学得出最优解释，万万记着并发可跟并行不一样。

### 2.1 并发 ###

在某个时间段内，多个程序都处在执行和执行完毕之间；但在一个时间点上只有一个程序在运行。头脑风暴：老鹰妈妈喂小雏鹰食物，小雏鹰很多，而老鹰只有一张嘴，她需要一个个喂过去，到最后每个小雏鹰都可以吃到，但是在一个时间点里只能有一个小雏鹰可以吃到美味的食物。

### 2.2 并行 ###

在某个时间段里，每个程序按照自己独立异步的速度执行，程序之间互不干扰。头脑风暴：这就好似老鹰妈妈决定这样喂食太费劲于是为每个小雏鹰请了个保姆，这样子在一个时间点里，每个小雏鹰都可以同时吃到食物，而且互相不干扰。

回到线程池，控制线程池的并发数可以有效的避免大量的线程池争夺CPU资源而造成堵塞。头脑风暴：还是拿老鹰的例子来讲，妈妈只有一个，要这么一个个喂下去，一些饿坏的小雏鹰等不下去了就要破坏规则，抢在靠前喂食的雏鹰面前，而前面的雏鹰也不是吃软饭的，于是打起来了，场面混乱。老鹰生气了，这么不懂事，谁也别吃了，于是造成了最后谁也没食吃的局面。

## **3、线程池可以对线程进行管理** ##

线程池可以提供定时、定期、单线程、并发数控制等功能。比如通过ScheduledThreadPool线程池来执行S秒后，每隔N秒执行一次的任务。

# 二、线程池的详解 #

推荐博客：[http://blog.csdn.net/seu\_calvin/article/details/52415337][http_blog.csdn.net_seu_calvin_article_details_52415337]

想必看完上面那篇博客，大家可谓赞不绝口，不过可能有些小伙伴还是记不下来，还有些小伙伴觉得好恶心呀，怎么都是厕所啥的呀！哈哈别着急，我来给大家一种好记的办法。

先来讲讲参数最多的那个构造方法，主要是对那几个烦人的参数进行分析。

## 1、ThreadPoolExecutor ##

public ThreadPoolExecutor(int corePoolSize,  
                                  int maximumPoolSize,  
                                  long keepAliveTime,  
                                  TimeUnit unit,  
                                  BlockingQueue<Runnable> workQueue,  
                                  ThreadFactory threadFactory,  
                                  RejectedExecutionHandler handler)

这里是7个参数(我们在开发中用的更多的是5个参数的构造方法)，OK，那我们来看看这里七个参数的含义：

*  corePoolSize  线程池中核心线程的数量
 *  maximumPoolSize  线程池中最大线程数量
 *  keepAliveTime 非核心线程的超时时长，当系统中非核心线程闲置时间超过keepAliveTime之后，则会被回收。如果ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，则该参数也表示核心线程的超时时长
 *  unit 第三个参数的单位，有纳秒、微秒、毫秒、秒、分、时、天等
 *  workQueue 线程池中的任务队列，该队列主要用来存储已经被提交但是尚未执行的任务。存储在这里的任务是由ThreadPoolExecutor的execute方法提交来的。
 *  threadFactory  为线程池提供创建新线程的功能，这个我们一般使用默认即可
 *  handler 拒绝策略，当线程无法执行新任务时（一般是由于线程池中的线程数量已经达到最大数或者线程池关闭导致的），默认情况下，当线程池无法处理新线程时，会抛出一个RejectedExecutionException。
 *  emmmmm....看到那么多烦人的概念，是不是有点头大了，我反正是头大了。

这7个参数中，平常最多用到的是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue.在这里我主抽出**corePoolSize、maximumPoolSize和****workQueue**三个参数进行详解。maximumPoolSize(最大线程数) = corePoolSize(核心线程数) + noCorePoolSize(非核心线程数)；

1.  当currentSize<corePoolSize时，没什么好说的，直接启动一个核心线程并执行任务。
2.  当currentSize>=corePoolSize、并且workQueue未满时，添加进来的任务会被安排到workQueue中等待执行。
3.  当workQueue已满，但是currentSize<maximumPoolSize时，会立即开启一个非核心线程来执行任务。
4.  当currentSize>=corePoolSize、workQueue已满、并且currentSize>maximumPoolSize时，调用handler默认抛出RejectExecutionExpection异常。

表格表示一下

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>参数</td> 
   <td>含义</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>corePoolSize</td> 
   <td>核心工作线程数</td> 
   <td>没有任务时，线程池中允许存在的最小空闲线程数&nbsp;<br><code>工作线程数 &lt; corePoolSize</code>时，提交任务创建工作线程来执行任务</td> 
  </tr> 
  <tr> 
   <td>maximumPoolSize</td> 
   <td>最大工作线程数</td> 
   <td>线程池中允许出现的最大工作线程数量&nbsp;<br> 当<code>队列满 &amp;&amp; 工作线程数 &lt; maximumPoolSize</code>时，新的队列将创建线程来执行；<br> 如果<code>队列没有边界</code>，那么这个参数没有意义</td> 
  </tr> 
  <tr> 
   <td>workQueue</td> 
   <td>任务队列</td> 
   <td>保存待执行任务的阻塞队列；<br> 当&nbsp;<code>(工作线程数 &gt;= corePoolSize) &amp;&amp; (任务数 &lt; 任务队列长度)</code>时，任务会offer()入队等待</td> 
  </tr> 
  <tr> 
   <td>keepAliveTime</td> 
   <td>工作线程最大空闲时间</td> 
   <td>当<code>线程数 &gt; corePoolSize</code>时，这个参数表示空闲线程存活时间；<br> 超时的空闲线程，会被回收掉，直到<code>线程数==corePoolSzie</code>;&nbsp;<br> 当<code>allowCoreThreadTimeOut=true</code>时，则超时的核心工作线程也会被回收</td> 
  </tr> 
  <tr> 
   <td>unit</td> 
   <td>时间单位</td> 
   <td>keepAliveTime的时间单位</td> 
  </tr> 
  <tr> 
   <td>threadFactory</td> 
   <td>线程创建工厂</td> 
   <td>创建线程的工厂类，可以在这里指定创建线程的name，设置守护线程，异常case处理等</td> 
  </tr> 
  <tr> 
   <td>handler</td> 
   <td>饱和策略执行器</td> 
   <td>线程池和队列都已满时，新提交任务的处理策略&nbsp;<br> 默认是Abort(直抛Reject异常)，包括Discard(LIFO规则丢弃)、DiscardOldest(LRU规则丢弃) 以及 CallerRuns(调用者线程执行)，允许自定义执行器</td> 
  </tr> 
 </tbody> 
</table>

什么currentSize,corePoolSize,maximumPoolSize,workQueue比来比去的都比迷糊了，哈哈，那我举个烧烤店的例子来想必大家理解起来更快。

夏天了，很热，所以很多烧烤店都会在外面也布置座位，分为室内、室外两个地方可以吃烧烤。（室内有空调电视，而且室内比室外烧烤更加优惠，而且外面下着瓢泼大雨所以顾客会首先选择室内）

corePoolSize(烧烤店室内座位)，cuurentPoolSize（目前到烧烤店的顾客数量），maximumPoolSize（烧烤店室内+室外+侯厅室所有座位），workQueue(烧烤店为顾客专门设置的侯厅室)

第（1）种，烧烤店人数不多的时候，室内位置很多，大家都其乐融融，开心的坐在室内吃着烧烤，看着世界杯。

第（2）种，生意不错，室内烧烤店坐无空席，大家都不愿意去外面吃，于是在侯厅室里呆着，侯厅室位置没坐满。

第（3）种，生意兴隆，室内、侯厅室都坐无空席，但是顾客太饿了，剩下的人没办法只好淋着雨吃烧烤，哈哈，好可怜。

第（4）种，生意爆棚，室内、室外、侯厅室都坐无空席，在有顾客过来直接赶走。

哈哈是不是很形象，对于workQueue还是有点陌生的小伙伴。

推荐博客:http://blog.csdn.net/u012702547/article/details/52259529

## 2、其他线程池的记法 ##

剩下的那四种主要的线程池大概思路，用法在我推荐的博客里都有详细解说，在这里我就不一一道来了，在这里主要是跟大家分享一种特别容易记住这四种线程池的方法，在大家写代码，面试时可以即使想到这四种线程池。

### （1）FixedThreadPool: ###

Fixed中文解释为固定。结合在一起解释固定的线程池，说的更全面点就是，有固定数量线程的线程池。其corePoolSize=maximumPoolSize，且keepAliveTime为0，适合线程稳定的场所。

### （2）SingleThreadPool: ###

Single中文解释为单一。结合在一起解释单一的线程池，说的更全面点就是，有固定数量线程的线程池，且数量为一，从数学的角度来看SingleThreadPool应该属于FixedThreadPool的子集。其corePoolSize=maximumPoolSize=1,且keepAliveTime为0，适合线程同步操作的场所。

### （3）CachedThreadPool: ###

Cached中文解释为储存。结合在一起解释储存的线程池，说的更通俗易懂，既然要储存，其容量肯定是很大，所以他的corePoolSize=0，maximumPoolSize=Integer.MAX\_VALUE(2^32-1一个很大的数字)

### （4）ScheduledThreadPool: ###

Scheduled中文解释为计划。结合在一起解释计划的线程池，顾名思义既然涉及到计划，必然会涉及到时间。所以ScheduledThreadPool是一个具有定时定期执行任务功能的线程池。

# 三、线程池的单例 #

容我伸个懒腰，该讲本章重点内容了，在此之前，我们对基本语意知识进行了解一下。

什么是单例呢？咳咳。

## 1、单例 ##

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

**注意事项：**

*  1、单例类只能有一个实例。
 *  2、单例类必须自己创建自己的唯一实例。
 *  3、单例类必须给所有其他对象提供这一实例。

推荐：[http://www.runoob.com/design-pattern/singleton-pattern.html][http_www.runoob.com_design-pattern_singleton-pattern.html]

## 2、线程池的单例 ##

那么问题来了，我线程池用的好好的，用的时候创建一个，不用就不管他，那为什么要将线程池设计成单例模式呢。那么就要看看你将线程池应用的场所了。一般情况下，整个系统中只需要单种线程池，多个线程公用一个线程池，不会是每创一个线程就要创建一个线程池，那样子你还不如不用线程池呢。

>     private ThreadPool(int corepoolsize, int maximumpoolsize, long keepalivetime){
>                 this.corepoolsize = corepoolsize;
>                 this.maximumpoolsize = maximumpoolsize;
>                 this.keepalivetime = keepalivetime;
>             }
>     public void executor(Runnable runnable){
>      
>                 if (runnable == null){
>                     return;
>                 }
>                 if (mexecutor == null){
>                     mexecutor = new ThreadPoolExecutor(corepoolsize, //核心线程数
>                             maximumpoolsize, //最大线程数
>                             keepalivetime, //闲置线程存活时间
>                             TimeUnit.MILLISECONDS, // 时间单位
>                             new LinkedBlockingDeque<Runnable>(), //线程队列
>                             Executors.defaultThreadFactory(), //线程工厂
>                             new ThreadPoolExecutor.AbortPolicy() //队列已满，而且当前线程数已经超过最大线程数时的异常处理策略
>                     );
>                 }
>                 mexecutor.execute(runnable);
>             }
> 
>

再然后对ThreadPool内部类，在类里面对他实例化，实现单例

### Demo地址：[https://download.csdn.net/download/fengye454545/10284814][https_download.csdn.net_download_fengye454545_10284814] ###

# 四、可选择的饱和策略RejectedExecutionHandler详解 #

JDK主要提供了4种饱和策略供选择。4种策略都做为静态内部类在ThreadPoolExcutor中进行实现。

## 1、AbortPolicy中止策略 ##

该策略是默认饱和策略。使用该策略时在饱和时会抛出RejectedExecutionException（继承自RuntimeException），调用者可捕获该异常自行处理。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                throw new RejectedExecutionException("Task " + r.toString() +
                                                     " rejected from " +
                                                     e.toString());
     }

## 2、DiscardPolicy抛弃策略 ##

如代码所示，不做任何处理直接抛弃任务

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }

## 3、DiscardOldestPolicy抛弃旧任务策略 ##

如代码，先将阻塞队列中的头元素出队抛弃，再尝试提交任务。如果此时阻塞队列使用PriorityBlockingQueue优先级队列，将会导致优先级最高的任务被抛弃，因此不建议将该种策略配合优先级队列使用。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                if (!e.isShutdown()) {
                    e.getQueue().poll();
                    e.execute(r);
                }
    }

## 4、 CallerRunsPolicy调用者运行 ##

既不抛弃任务也不抛出异常，直接运行任务的run方法，换言之将任务回退给调用者来直接运行。使用该策略时线程池饱和后将由调用线程池的主线程自己来执行任务，因此在执行任务的这段时间里主线程无法再提交新任务，从而使线程池中工作线程有时间将正在处理的任务处理完成。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                if (!e.isShutdown()) {
                    r.run();
                }
    }

[http_blog.csdn.net_fengye454545_article_details_79536986]: http://blog.csdn.net/fengye454545/article/details/79536986
[http_blog.csdn.net_seu_calvin_article_details_52415337]: http://blog.csdn.net/seu_calvin/article/details/52415337
[http_www.runoob.com_design-pattern_singleton-pattern.html]: http://www.runoob.com/design-pattern/singleton-pattern.html
[https_download.csdn.net_download_fengye454545_10284814]: https://download.csdn.net/download/fengye454545/10284814