2024年java面试--多线程(2)

梦里梦外; 2024-03-26 22:45 94阅读 0赞

## 系列文章目录 ##

1.  [2024年java面试（一）–spring篇][2024_java_spring]
2.  [2024年java面试（二）–spring篇][2024_java_spring 1]
3.  [2024年java面试（三）–spring篇][2024_java_spring 2]
4.  [2024年java面试（四）–spring篇][2024_java_spring 3]
5.  [2024年java面试–集合篇][2024_java]
6.  [2024年java面试–redis(1)][2024_java_redis_1]
7.  [2024年java面试–redis(2)][2024_java_redis_2]

--------------------

#### 文章目录 ####

*  系列文章目录
 *  线程池
 *   *  1、使用线程池
     *  2、线程池构造函数
     *  3、线程处理任务过程
     *  4、线程拒绝策略
     *  5、Execuors类实现线程池
     *  6、线程池大小设置
     *  7、为何使用线程池
     *  8、阻塞队列的作用
     *  9、线程池中线程复用原理

--------------------

## 线程池 ##

### 1、使用线程池 ###

（底层都是实现run方法）

static class DefaultThreadFactory implements ThreadFactory {
        
        DefaultThreadFactory() {
        
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" + poolNumber.getAndIncrement() +"-thread-";
        }
        public Thread newThread(Runnable r) {
        
            Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);
            if (t.isDaemon()) t.setDaemon(false);  //是否守护线程
            if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); //线程优先级
            return t;
        }
    }

**好处**：

1.提高响应速度（减少了创建新线程的时间）

2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）

3.便于线程管理

优点：通过复用已创建的线程，**降低资源损耗**、线程可以直接处理队列中的任务**加快响应速度**、同时便于**统一监控和管理**。

--------------------

### 2、线程池构造函数 ###

/**
    * 线程池构造函数7大参数
    */
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
        TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,
        RejectedExecutionHandler handler) {
        }

**参数介绍：**

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>corePoolSize</td> 
   <td>核心线程池大小，核心线程数，也就是正常情况下创建工作的线程数，这些线程创建后并不会消除，而是一种常驻线程</td> 
  </tr> 
  <tr> 
   <td>maximumPoolSize</td> 
   <td>最大线程池大小，最大线程数，它与核心线程数相对应，表示最大允许被创建的线程数，比如当前任务较多，将核心线程数都用完了，还无法满足需求时，此时就会创建新的线程，但是线程池内线程总数不会超过最大线程数</td> 
  </tr> 
  <tr> 
   <td>keepAliveTime</td> 
   <td>线程池中超过 corePoolSize 数目的空闲线程最大存活时间；超出核心线程数之外的线程的空闲存活时间，也就是核心线程不会消除，但是超出核心线程数的部分线程如果空闲一定的时间则会被消除,我们可以通过 setKeepA7iveTime来设置空闲时间</td> 
  </tr> 
  <tr> 
   <td>TimeUnit</td> 
   <td>keepAliveTime 时间单位</td> 
  </tr> 
  <tr> 
   <td>workQueue</td> 
   <td>阻塞任务队列，用来存放待执行的任务，假设我们现在核心线程都已被使用，还有任务进来则全部放入队列，直到整个队列被放满但任务还再持续进入则会开始创建新的线程</td> 
  </tr> 
  <tr> 
   <td>threadFactory</td> 
   <td>新建线程工厂，是一个线程工厂，用来生产线程执行任务。我们可以选择使用默认的创建工厂，产生的线程都在同一个组内，拥有相同的优先级，且都不是守护线程。当然我们也可以选择自定义线程工厂，一般我们会根据业务来制定不同的线程工厂</td> 
  </tr> 
  <tr> 
   <td>RejectedExecutionHandler</td> 
   <td>拒绝策略。当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理，任务拒绝策略，有两种情况，第一种是当我们调用shutdown 等方法关闭线程池后，这时候即使线程池内部还有没执行完的任务正在执行，但是由于线程池已经关闭，我们再继续想线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数，线程池已经没有能力继续处理新提交的任务时，这是也就拒绝</td> 
  </tr> 
 </tbody> 
</table>

**拒绝策略：**

*  AbortPolicy：直接抛出异常，默认策略；
 *  CallerRunsPolicy：用调用者所在的线程来执行任务；
 *  DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
 *  DiscardPolicy：直接丢弃任务；当然也可以根据应用场景实现 RejectedExecutionHandler 接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务

--------------------

### 3、线程处理任务过程 ###

![请添加图片描述][d887636846cf489089b92158e20f9404.png]  
![请添加图片描述][989a4282fa5349ebaa5069c42bc52ecd.png]  
1.当线程池小于corePoolSize，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。

2.当线程池达到corePoolSize时，新提交任务将被放入 workQueue 中，等待线程池中任务调度执行。

3.当workQueue已满，且 maximumPoolSize 大于 corePoolSize 时，新提交任务会创建新线程执行任务。

4.当提交任务数超过 maximumPoolSize 时，新提交任务由 RejectedExecutionHandler 处理。

5.当线程池中超过corePoolSize 线程，空闲时间达到 keepAliveTime 时，关闭空闲线程 。

--------------------

### 4、线程拒绝策略 ###

线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。

JDK 内置的拒绝策略如下：

**AbortPolicy**： 直接抛出异常，阻止系统正常运行。可以根据业务逻辑选择重试或者放弃提交等策略。

**CallerRunsPolicy** ： 只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。  
不会造成任务丢失，同时减缓提交任务的速度，给执行任务缓冲时间。

**DiscardOldestPolicy** ： 丢弃最老的一个请求，也就是即将被执行的任务，并尝试再次提交当前任务。

**DiscardPolicy** ： 该策略默默地丢弃无法处理的任务，不予任何处理。如果允许任务丢失，这是最好的一种方案。

--------------------

### 5、Execuors类实现线程池 ###

![请添加图片描述][04e8059b59ca4fa7857f8312072ed00b.png]

*  **newSingleThreadExecutor**()： 只有一个线程的线程池，任务是顺序执行，适用于一个一个任务执行的场景
 *  **newCachedThreadPool**()： 线程池里有很多线程需要同时执行，60s内复用，适用执行很多短期异步的小程序或者负载较轻的服务
 *  **newFixedThreadPool**()： 拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务。
 *  **newScheduledThreadPool**()： 用来调度即将执行的任务的线程池
 *  **newWorkStealingPool**() ：底层采用forkjoin的Deque，采用独立的任务队列可以减少竞争同时加快任务处理  
    ![请添加图片描述][58076feabd9d421383dba5a461047b33.png]  
    **因为以上方式都存在弊端：**

FixedThreadPool 和 SingleThreadExecutor ： 允许请求的**队列⻓度**为 Integer.MAX\_VALUE，会导致OOM。

CachedThreadPool 和 ScheduledThreadPool ： 允许创建的**线程数量**为 Integer.MAX\_VALUE，会导致OOM。

手动创建的线程池底层使用的是ArrayBlockingQueue可以防止OOM。

--------------------

### 6、线程池大小设置 ###

*  CPU 密集型（n+1）

CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。

CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。

*  IO 密集型（2\*n）

由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU \* 2

也可以使用公式：CPU 核心数 \*（1+平均等待时间/平均工作时间）。

--------------------

### 7、为何使用线程池 ###

优点：通过复用已创建的线程，**降低资源损耗**、线程可以直接处理队列中的任务**加快响应速度**、同时便于**统一监控和管理**。

**1.降低资源消耗**

线程的创建和销毁会造成一定的时间和空间上的消耗，线程池可以让我们重复利用已创建的线程。

**2.提高响应速度**

线程池已为我们创建好了线程，当任务到达时可以不需要等到线程创建就能立即执行。

**3.提高线程的可管理性**

线程是稀缺资源，不可能无限的创建，使用线程池可以进行统一分配、调优和监控。

**4.提供更多更强大的功能**

线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行。

--------------------

### 8、阻塞队列的作用 ###

1、一般的队列只能保证作为一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了，阻塞队列通过阻塞可以保留住当前想要继续入队的任务。

阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。

阻塞队列自带阻塞和唤醒的功能，不需要额外处理，无任务执行时,线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活、不至于一直占用cpu资源

**为什么是先添加队列而不是先创建最大线程？**

在创建新线程的时候，是要获取全局锁的，这个时候其它的就得阻塞，影响了整体效率。

--------------------

### 9、线程池中线程复用原理 ###

线程池将线程和任务进行解耦，线程是线程，任务是任务，摆脱了之前通过Thread创建线程时的一个线程必须对应一个任务的限制。

在线程池中，同一个线程可以从阻塞队列中不断获取新任务来执行，其核心原理在于线程池对Thread进行了封装，并不是每次执行任务都会调用Thread.start()来创建新线程，而是让每个线程去执行一个"循环任务"，在这个"循环任务"中不停检查是否有任务需要被执行，如果有则直接执行，也就是调用任务中的run方法，将run方法当成一个普通的方法执行，通过这种方式只使用固定的线程就将所有任务的run方法串联起来。

[2024_java_spring]: https://blog.csdn.net/weixin_43228814/article/details/132514449?spm=1001.2014.3001.5502
[2024_java_spring 1]: https://blog.csdn.net/weixin_43228814/article/details/132521303?spm=1001.2014.3001.5502
[2024_java_spring 2]: https://blog.csdn.net/weixin_43228814/article/details/132524089?spm=1001.2014.3001.5502
[2024_java_spring 3]: https://blog.csdn.net/weixin_43228814/article/details/132525745?spm=1001.2014.3001.5502
[2024_java]: https://blog.csdn.net/weixin_43228814/article/details/132548267?spm=1001.2014.3001.5502
[2024_java_redis_1]: https://blog.csdn.net/weixin_43228814/article/details/132575813?spm=1001.2014.3001.5502
[2024_java_redis_2]: https://blog.csdn.net/weixin_43228814/article/details/132590649?spm=1001.2014.3001.5502
[d887636846cf489089b92158e20f9404.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/36ba0a4183b44a79b45bf5ad39ef427c.png
[989a4282fa5349ebaa5069c42bc52ecd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/9ae25108f4db4a44913188c939880a53.png
[04e8059b59ca4fa7857f8312072ed00b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/05469dbc23f548e1be95cee3fc408374.png
[58076feabd9d421383dba5a461047b33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/84ca8b9081dd429dad9c64ca87e25713.png