java——》ExecutorService

阳光穿透心脏的1/2处 2023-11-09 07:30 205阅读 0赞

版权声明：本文为博主原创文章，无需授权即可转载，甚至无需保留以上版权声明，转载时请务必注明作者。  
[https://blog.csdn.net/weixin\_43453386/article/details/88661622][https_blog.csdn.net_weixin_43453386_article_details_88661622]

#### java——》ExecutorService ####

*  一、线程池相关概念
 *   *  1、为什么需要创建线程池
     *  2、线程池的好处
 *  二、创建线程池
 *  三、线程池的类型
 *   *  1、可缓存线程池
     *  2、单线程池
     *  3、固定线程数线程池
     *  4、固定线程数，支持定时和周期性任务

## 一、线程池相关概念 ##

### 1、为什么需要创建线程池 ###

*  （1）服务器如果每一个请求都会创建一个新线程，会导致性能上的瓶颈，因为线程创建和销毁都需要jvm不停的处理，如果一个线程执行的时间 < (线程创建时间+线程销毁的时间)的时候，我们就要考虑线程的复用了！
 *  （2）线程数量创建过多，没有有效的管理，反而起到的是副作用，会大大降低系统的性能的！
 *  （3）我们要根据具体的业务需求不同，结合操作系统的处理器CPU核数，能够合理的控制线程池大小！选择不同策略的线程池，盲目使用也会带来一定风险，比如内存泄漏，死锁，并发问题…

### 2、线程池的好处 ###

*  （1）降低资源消耗：线程复用。
 *  （2）提高响应速度：有任务的时候，不需要去等待创建线程，直接使用已有的线程；
 *  （3）管理：线程池对线程进行统一分配，调优，监控等等；

## 二、创建线程池 ##

//所有线程池最终都是通过这个方法来创建的
    public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler)

<table> 
 <thead> 
  <tr> 
   <th align="left">参数</th> 
   <th align="left">说明</th> 
   <th align="left">具体说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">corePoolSize</td> 
   <td align="left">核心线程数</td> 
   <td align="left">一旦创建将不会再释放。<br><br>如果创建的线程数还没有达到指定的核心线程数量，<br>将会继续创建新的核心线程，<br>直到达到最大核心线程数后，<br>核心线程数将不在增加；<br><br>如果没有空闲的核心线程，<br>同时又未达到最大线程数，<br>则将继续创建非核心线程；<br><br>如果核心线程数等于最大线程数，<br>则当核心线程都处于激活状态时，<br>任务将被挂起，<br>等待空闲线程来执行。</td> 
  </tr> 
  <tr> 
   <td align="left">maximumPoolSize</td> 
   <td align="left">最大线程数</td> 
   <td align="left">允许创建的最大线程数量。<br><br>如果最大线程数等于核心线程数，<br>则无法创建非核心线程；<br>如果非核心线程处于空闲时，<br>超过设置的空闲时间则将被回收，<br>释放占用的资源。</td> 
  </tr> 
  <tr> 
   <td align="left">keepAliveTime</td> 
   <td align="left">最大时间</td> 
   <td align="left">也就是当线程空闲时，<br>所允许保存的最大时间，<br>超过这个时间，<br>线程将被释放销毁，<br>但只针对于非核心线程。</td> 
  </tr> 
  <tr> 
   <td align="left">unit</td> 
   <td align="left">时间单位</td> 
   <td align="left">TimeUnit.SECONDS等</td> 
  </tr> 
  <tr> 
   <td align="left">workQueue</td> 
   <td align="left">任务队列</td> 
   <td align="left">存储暂时无法执行的任务，<br>等待空闲线程来执行任务。</td> 
  </tr> 
  <tr> 
   <td align="left">threadFactory</td> 
   <td align="left">线程工程</td> 
   <td align="left">用于创建线程</td> 
  </tr> 
  <tr> 
   <td align="left">handler</td> 
   <td align="left">处理阻塞时的程序</td> 
   <td align="left">当线程边界和队列容量已经达到最大时，<br>用于处理阻塞时的程序</td> 
  </tr> 
 </tbody> 
</table>

## 三、线程池的类型 ##

### 1、可缓存线程池 ###

>  *  创建的都是非核心线程
>  *  最大线程数为Interge的最大值
>  *  空闲线程存活时间是1分钟
>  *  适用于生命周期短的任务，如果有大量耗时的任务，则不适该创建方式

ExecutorService cachePool = Executors.newCachedThreadPool();

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

### 2、单线程池 ###

>  *  创建一个核心线程
>  *  保证任务按FIFO顺序一个个执行

ExecutorService singlePool = Executors.newSingleThreadExecutor();

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

### 3、固定线程数线程池 ###

>  *  创建固定数量的可复用的线程数
>  *  当线程数达到最大核心线程数，则加入队列等待有空闲线程时再执行

ExecutorService fixedPool = Executors.newFixedThreadPool(3);

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

### 4、固定线程数，支持定时和周期性任务 ###

>  *  可用于替代handler.postDelay和Timer定时器等延时和周期性任务

ExecutorService scheduledPool = Executors.newScheduledThreadPool(5);

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

public ScheduledFuture<?> schedule(Runnable command,
                                           long delay, 
                                           TimeUnit unit);

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                      long initialDelay,
                                                      long period,
                                                      TimeUnit unit);

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                         long initialDelay,
                                                         long delay,
                                                         TimeUnit unit);

>  *  scheduleAtFixedRate  
>       
>     创建并执行一个在给定初始延迟后的定期操作（在 initialDelay 后开始执行）  
>       
>     在initialDelay+period 后下一个任务执行，  
>       
>     接着在 initialDelay + 2 \* period 后执行，  
>       
>     依此类推 ，也就是只在第一次任务执行时有延时。

>  *  sheduleWithFixedDelay  
>       
>     创建并执行一个在给定初始延迟后首次启用的定期操作  
>       
>     在每一次执行终止和下一次执行开始之间都存在给定的延迟，即总时间是（initialDelay + period）\*n

[https_blog.csdn.net_weixin_43453386_article_details_88661622]: https://blog.csdn.net/weixin_43453386/article/details/88661622