Java面试题集锦(9)：线程池的使用

最新推荐文章于 2023-02-17 14:35:22 发布

秋心拆两半_

最新推荐文章于 2023-02-17 14:35:22 发布

阅读量158

点赞数

分类专栏： Java并发面试题文章标签： java

本文链接：https://blog.csdn.net/qq_36755571/article/details/111404391

版权

Java并发面试题专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1. 为什么用线程池，优势是什么?

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程就会排队等候，等其它线程执行完毕，再从队列中取出任务来执行。
主要特点：线程复用，控制最大并发数，管理线程
主要优点：

降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。
提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。

2. 线程池如何使用

在这里插入图片描述
Java中的线程池是通过Executor框架实现的，该框架中用到来EXecutor，Executors，ExecutorService，ThreadPoolExecutor这几个类。
Java的线程池目前总共有5种：
Executors.newFixedThreadPool(int) 一池固定线程
Executors.newSingleThreadExecutor() 一池一线程
Executors.newCachedThreadPool() 一池多线程
此外还有
Executors.newScheduledThreadPool()带时间调用的
Executors.newWorkStealingThreadPool(int)，Java新增，使用目前机器上可用的处理器作为它的并性级别

1）newFixedThreadPool例子

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
* Array Arrays
* Collection Collections
* Executor Executors
* 上述类比记忆，+s是辅助工具类，里面有辅助的方法
*/
public class MyThreadPoolDemo {
    public static void main(String[] args) throws Exception {
        //一池5线程，模拟银行的五个窗口
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        //模拟10个用户来办理业务，每个用户就是一个外部的请求线程
        try{
            for(int i=0;i<10;i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t 线程池处理业务。");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

一池5线程，运行结果：
在这里插入图片描述
线程池中的5个线程处理10个业务，线程复用。

newFixedThreadPool使用场景：执行长期的任务，性能好很多。

2）newSingleThreadExecutor例子

public class MyThreadPoolDemo {
    public static void main(String[] args) throws Exception {
        //一池1线程，模拟周末的银行
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        //模拟10个用户来办理业务，每个用户就是一个外部的请求线程
        try{
            for(int i=0;i<10;i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t 线程池处理业务。");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

newSingleThreadExecutor使用场景：一个任务一个任务执行的场景。

3）newCachedThreadPool例子
如果不用sleep，所有任务一齐交给线程池

public class MyThreadPoolDemo {
    public static void main(String[] args) throws Exception {
        //一池1线程，模拟周末的银行
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //模拟10个用户来办理业务，每个用户就是一个外部的请求线程
        try{
            for(int i=0;i<10;i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t 线程池处理业务。");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

在这里插入图片描述
动态来创建新线程

		try{
            for(int i=0;i<10;i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t 线程池处理业务。");
                });
                try{
                    TimeUnit.MILLISECONDS.sleep(200);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }

加了sleep之后，可以只用一个线程完成所有任务。

newCachedThreadPool使用场景：执行很多短期异步的小程序或者负载较轻的服务器。

上述三种线程池的底层是什么
ThreadPoolExcutor
以newFixedThreadPool为例：

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

三者底层都是创建了ThreadPoolExcutor，其中有一个参数是阻塞队列！

3. 线程池的几个重要参数

线程池中有5个重要参数，但是底层一共有7个参数

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

corePoolSize：线程池中的常驻核心线程数。
maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值必须大于等于1。
keepAliveTime：多余的空闲线程的存活时间。当前线程池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。
unit：keepAliveTime的单位。
workQueue：任务队列，被提交但尚未被执行的任务。
threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程，一般用默认的即可。
handler：拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时，选择的拒绝方式。拒绝策略分为：Abort 策略, CallerRuns 策略,Discard策略，DiscardOlds策略。

※ThreadPoolExecutor的源码

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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

4. 说说线程池的底层工作原理

参考下图，背过线程池的工作工程。
在这里插入图片描述
线程池的工作工程：

在创建了线程池后，等待提交过来的任务请求。
当调用execute() 方法添加一个请求任务时，线程池会做如下判断:
2.1如果正在运行的线程数量小于corePoolSize,那么马上创建线程运行这个任务:
2.2 如果正在运行的线程数量大于或等于corePoolSize, 那么将这个任务放入队列:
2.3如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize,那么还是要创建非核心线程立刻运行这个任务（发生了抢占）;
2.4如果队列满了且正在运行的线程数量大于或等于maximumPoolSize,那么线程池会启动饱和拒绝策略来执行。
当一个线程完成任务时，它会从队列中取下一-个任务来执行。
当一个线程无事可做超过一定的时间(keepAliveTime) 时，线程池会判断:
如果当前运行的线程数大于corePoolSize,那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小

5. 线程池的拒绝策略

拒绝策略：等待队列已经满了，再也塞不下新任务了，同时，线程池中线程数也达到了最大线程数maximumPoolSize，无法继续为新任务服务。这时，我们就需要拒绝策略机制合理的处理这个问题。
1. AbortPolicy：直接抛出RejectedExecutionException异常，阻止系统正常运行。
2. CallerRunsPolicy：“调用者运行”一种调节机制，该策略既不会抛出任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
3. DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案。
4. DiscardOldsPolicy：丢弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。

6. 题目1

问题： 你在工作中单一的/固定的/可变的三种创建线程池的方法，你用哪个比较多？
回答： 一个都不用，我们生产上只能使用自定义的。
再问： JDK给你提供了，为什么不用？
回答： 见下图（转自阿里Java开发手册）

7. 手写线程池Demo

1.本例使用的是AbortPolity拒绝策略，maximunPoolsize=5，BlockingQueue的容量为3，所以当执行到第九个任务时，报了java.util.concurrent.RejectedExecutionException异常。

class Scratch {
    public static void main(String[] args) throws Exception {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        try{
            //模拟10个人去银行办理业务.
            //打开的柜台为2，总共有柜台5，
            //等候区大小为3
            for(int i=0;i<10;i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t  办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

在这里插入图片描述
2.本例改为CallerRunsPolicy拒绝策略。重新解读一下CallerRunsPolicy()的意思：“调用者运行”一种调节机制，该策略既不会抛出任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
因为是main线程中创建的线程池，所以调用者是main线程。
所以回退到了main线程。
在这里插入图片描述
3.本例改为DiscardPolicy拒绝策略。

只执行了8个任务（maximumPoolSize + BlockingQueue的容量），之后的直接拒绝掉了.
4.本例改为DiscardOldestPolicy拒绝策略。

只执行了8个任务（maximumPoolSize + BlockingQueue的容量），之后的拒绝掉了，拒绝了等待时间最久的2个。

8. 题目2：如何合理配置线程池中的线程数？

具体根据业务场景的不同，可以分为CPU密集型和IO密集型。

System.out.println(Runtime.getRuntime().availableProcessors());

可以查看CPU的核数的。

CPU密集型的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行；
CPU密集任务只有在真正的多核CPU上才可能得到加速（通过多线程）；
CPU密集型任务配置尽可能少的线程数量，一般公式：CPU核数+1个线程的线程池。
由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如 CPU核数*2；
IO密集型时，大部分线程都阻塞，故需要多配置线程数，参考公式：CPU核数/（1-阻塞系数），阻塞系数在0.8~0.9之间，比如8核CPU创建的合理线程数为80个。

9. 使用线程池的好处

线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。
线程池节省了CLR 为每个短生存周期任务创建一个完整的线程的开销并可以在任务完成后回收资源。
线程池根据当前在系统中运行的进程来优化线程时间片。
线程池允许我们开启多个任务而不用为每个线程设置属性。
线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。
线程池可以用来解决处理一个特定请求最大线程数量限制问题。

秋心拆两半_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java面试题集锦(9)：线程池的使用

1. 为什么用线程池，优势是什么?线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程就会排队等候，等其它线程执行完毕，再从队列中取出任务来执行。主要特点：线程复用，控制最大并发数，管理线程主要优点：降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，
复制链接

扫一扫