线程池原理-参数详解

￡神魔★判官ぃ 2022-05-16 15:49 337阅读 0赞

## 零. 用线程池的好处 ##

1.  **线程的复用**:重用存在的线程,减少对象的创建,消亡的开销,性能好
2.  **控制线程的并发数**：控制线程池中线程的并发数，可以防止大量线程争夺CPU资源而造成的堵塞。比如用,FixedThreadPool 可以控制线程的最大并发数，超出部分在队列中等待。
3.  **可以对线程进行管理**：线程池可以提供定时执行、定期执行，单线程,空闲线程由JVM回收。

## 一. Executors类里面提供了一些静态工厂，生成一些常用的线程池： ##

<table> 
 <thead> 
  <tr> 
   <th>Executors，类创建线程池类型</th> 
   <th>作用</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Executors.newCachedThreadPool()</td> 
   <td>创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。</td> 
   <td>很灵活，弹性的线程池线程管理，用多少线程给多大的线程池，不用后及时回收，用则新建</td> 
   <td>一旦线程无限增长，会导致内存溢出</td> 
  </tr> 
  <tr> 
   <td>Executors.newFixedThreadPool()</td> 
   <td>创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。</td> 
   <td>创建一个固定大小线程池，超出的线程会在队列中等待</td> 
   <td>不支持自定义拒绝策略，大小固定，难以扩展</td> 
  </tr> 
  <tr> 
   <td>Executors.newScheduledThreadPool()</td> 
   <td>创建一个定长线程池，支持定时及周期性任务执行</td> 
   <td>创建一个固定大小线程池，可以定时或周期性的执行任务</td> 
   <td>任务是单线程方式执行，一旦一个任务失败其他任务也受影响</td> 
  </tr> 
  <tr> 
   <td>Executors.newSingleThreadPool()</td> 
   <td>创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。</td> 
   <td>创建一个单线程的线程池，保证线程的顺序执行</td> 
   <td>不适合并发</td> 
  </tr> 
 </tbody> 
</table>

创建线程之间关系：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70]

<table> 
 <thead> 
  <tr> 
   <th>ExecutorService</th> 
   <th>真正的线程池接口</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ScheduledExecutorService</td> 
   <td>能和Timer/TimerTask类似，解决那些需要任务重复执行的问题</td> 
  </tr> 
  <tr> 
   <td>ThreadPoolExecutor</td> 
   <td>ExecutorService的默认实现</td> 
  </tr> 
  <tr> 
   <td>ScheduledThreadPoolExecutor</td> 
   <td>继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。</td> 
  </tr> 
 </tbody> 
</table>

**ThreadPoolExecutor创建线程池**集中上面所有线程池的**优点**：

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

1.  corePoolSize：
    
        核心池大小corePoolSize：表示线程池维护线程的最少数量
        //这个参数10就是核心线程池的数量
        ExecutorService executorService = Executors.newFixedThreadPool(10);
2.  maximumPoolSize
    
        最大池大小maximumPoolSize：表示线程池维护线程的最大数量
3.  workQueue
    
        阻塞队列workQueue：表示如果任务数量超过核心池大小，多余的任务添加到阻塞队列中

*  corePoolSize、workQueue、maximumPoolSize的关系:
    
    前提假设：向线程池每添加一个任务就sleep。也就是说假设任务数与线程数一一对应，每添加一个任务就对应的创建一个线程，并且一直等待其他线程。 因为可能某一个线程执行了两个任务，看不出效果。
 *  a. 任务数 <= 核心池大小
    
    则每添加一个任务就会**创建一个线程**来执行该任务,线程最大数量等于核心池大小
 *  b. 最大线程数>任务数 > 核心池大小 && 设置的队列**没有满**
    
    任务放入到阻塞队列中
 *  c.最大线程数>任务数 > 核心池大小&&设置的队列**满了**  
    则会**创建新的线程**来处理新的任务
 *  d. 任务数 > 最大池大小  
    则会采用拒绝策略handler
 *  e. 核心线程数==最大线程数量  
    当任务等于核心线程数的时候，任务都往队列里面放，这时候不创建线程(因为允许的核心线程等于最大线程)

1.  keepAliveTime
    
        线程池维护线程所允许的空闲时间
2.  unit
    
        线程池维护线程所允许的空闲时间的单位
3.  threadFactory
    
        线程工厂,用来创建线程
4.  handler
    
        当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢,执行拒绝策略

ThreadPoolExecutor构造函数重要参数分析:  
ThreadPoolExecutor 3 个最重要的参数:  
1.corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。  
2.maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。  
3.workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，信任就会被存放在队列中。  
ThreadPoolExecutor其他常见参数:  
1.keepAliveTime:当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 keepAliveTime才会被回收销毁；  
2.unit : keepAliveTime 参数的时间单位。  
3.threadFactory :executor 创建新线程的时候会用到。  
4.handler :饱和策略。关于饱和策略下面单独介绍一下。

## 二. 线程执行和关闭 ##

1.  execute(): 提交任务,交给线程池执行
2.  submit(): 提交任务,能够返回执行结果,execute+Future
3.  shutdown(): 关闭线程池,等待任务执行完毕
4.  shutdownNow(): 关闭线程池,**不**等待任务执行完毕

## 三. workQueue 四种工作队列 ##

1.  **ArrayBlockingQueue**  
    基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略.
2.  **LinkedBlockingQuene**  
    基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
3.  **SynchronousQuene**  
    一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略
4.  **PriorityBlockingQueue**  
    具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

## 四. handler 四种拒绝策略 ##

1.  **CallerRunsPolicy**  
    直接由提交任务者执行这个任务shutdown，则直接抛弃任务.
2.  **AbortPolicy（默认策略）**  
    该策略下，直接丢弃任务，并抛出RejectedExecutionException异常，**该异常是非受检异常**，很容易忘记捕获。怎么捕获异常下面会详解
3.  **DiscardPolicy**  
    该策略下，直接丢弃任务，什么都不做。
4.  **DiscardOldestPolicy**  
    该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

## 五. 线程池的工作原理 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70 1]  
**原理**:就是每个参数配置配合时候,线程进入线程池的条件.

## 六.获取处理结果和异常 ##

线程池的处理结果、以及处理过程中的异常都被**包装到Future中**，并在调用**Future.get()方法时获取**，执行过程中的异常会被包装成ExecutionException，submit()方法本身不会传递结果和任务执行过程中的异常。获取执行结果的代码可以这样写：

ExecutorService executorService = Executors.newFixedThreadPool(4);
    Future<Object> future = executorService.submit(new Callable<Object>() { 
            @Override
            public Object call() throws Exception { 
                throw new RuntimeException("exception in call~");// 该异常会在调用Future.get()时传递给调用者
            }
        });
    	
    try { 
      Object result = future.get();
    } catch (InterruptedException e) { 
      // interrupt
    } catch (ExecutionException e) { 
      // exception in Callable.call()
      e.printStackTrace();
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70]: /images/20220503/7285f28f2ea74daf9d50ed09a131dfef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70 1]: /images/20220503/42b8cb1a59654717932b6e642af020e6.png