Java并发编程：线程池 ThreadPoolExector 学习篇

最新推荐文章于 2023-04-17 13:28:51 发布

不忘初心Eternity

最新推荐文章于 2023-04-17 13:28:51 发布

阅读量654

点赞数 1

分类专栏：并发编程学习文章标签： java线程池 ThreadPoolExector 并发编程

本文链接：https://blog.csdn.net/qq_41216743/article/details/102484971

版权

并发编程学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

常见大厂面试题型：

线程池使用过吗？谈谈对 ThreadPoolExector 的理解？
为什使用线程池，线程池的优势？
创建线程的几种方式？
线程池如何使用？
线程池的几个重要参数介绍？
说说线程池的底层工作原理？
线程池的拒绝策略你谈谈？
你在工作中单一的、固定数的和可变的三种创建线程池的方法，你用哪个多？
你在工作中是如何使用线程池的，是否自定义过线程池使用？
合理配置线程池你是如果考虑的？

带着问题学习，我相信能理解的更深刻，掌握的更多。

一、线程池使用过吗？谈谈对 ThreadPoolExector 的理解？

根据自己学习情况回答。

二、为什使用线程池，线程池的优势？

线程池用于多线程处理中，它可以根据系统的情况，可以有效控制线程执行的数量，优化运行效果。线程池做的工作主要是：控制运行的线程的数量，处理过程中将多余的任务放入阻塞队列，然后创建线程启动这些任务，如果线程数量超过了最大数量，那么超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

主要特点为：

线程复用
控制最大并发数量
管理线程

主要优点：

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

三、创建线程的几种方式

继承 Thread
实现 Runnable 接口
实现 Callable

举例：Thread 、Runnable就不举例了，下面是通过Callable接口实现：

public class CallableDemo {

public static void main(String[] args) throws ExecutionException, InterruptedException {

    // 在 FutureTask 中传入 Callable 的实现类
    FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            return 12;   
        }
    });

    // 把 futureTask 放入线程中
    new Thread(futureTask).start();

    // 获取结果
    Integer res = futureTask.get();
    System.out.println(res);

    }

}

四、线程池如何使用？

1、架构说明：

2、编码实现：

常用3种：

Executors.newSingleThreadExecutor()：只有一个线程的线程池，因此所有提交的任务是顺序执行，适用于一个一个任务执行的场景

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

Executors.newCachedThreadPool()：线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除，适用执行很多短期异步的小程序或者负载较轻的服务

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

Executors.newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务，性能好很多。

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

不常用：

Executors.newScheduledThreadPool()：用来调度即将执行的任务的线程池
Executors.newWorkStealingPool()： newWorkStealingPool适合使用在很耗时的操作，但是newWorkStealingPool不是ThreadPoolExecutor的扩展，它是新的线程池类ForkJoinPool的扩展，但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），所以适合使用在很耗时的任务中

可以发现每种方式的底层最终还是通过ThreadPoolExecutor来实现线程池

ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务。

五、线程池的几个重要参数介绍？

ThreadPoolExecutor底层源码，带有7个参数：

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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

核心参数：前5个

参数	作用
corePoolSize	核心线程池大小
maximumPoolSize	最大线程池大小
keepAliveTime	线程池中超过 corePoolSize 数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true) 使得核心线程有效时间
TimeUnit	keepAliveTime 时间单位
workQueue	阻塞任务队列
threadFactory	新建线程工厂
RejectedExecutionHandler	拒绝策略。当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理

六、说说线程池的底层工作原理？

重点讲解：

其中比较容易让人误解的是：参数corePoolSize，maximumPoolSize，workQueue之间关系。

当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
当线程池达到corePoolSize时，新提交任务将被放入 workQueue 中，等待线程池中任务调度执行。
当workQueue已满，且 maximumPoolSize 大于 corePoolSize 时，新提交任务会创建新线程执行任务。
当提交任务数超过 maximumPoolSize 时，新提交任务由 RejectedExecutionHandler 处理。
当线程池中超过corePoolSize 线程，空闲时间达到 keepAliveTime 时，关闭空闲线程。
当设置allowCoreThreadTimeOut(true) 时，线程池中 corePoolSize 线程空闲时间达到 keepAliveTime 也将关闭。

推荐看juc底层视频学习一下：本人学习教程，尚硅谷周阳线程池详解

七、线程池的拒绝策略你谈谈？

1、什么是拒绝策略：

等待队列已经满了，再也塞不下新的任务，同时线程池中的线程数达到了最大线程数max，无法继续为新任务服务。此时，我们需要拒绝策略机制合理的处理这个问题。也就是七大参数之一：RejectedExecutionHandler

2、拒绝策略有哪些：

AbortPolicy（默认）：处理程序遭到拒绝将抛出运行时 RejectedExecutionException，阻止系统的正常运行。

CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度，既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低任务的流量。

DiscardPolicy：不能执行的任务将被删除，直接丢弃任务

DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。抛弃队列中等待最久的任务

八、你在工作中单一的、固定数的和可变的三种创建线程池的方法，你用哪个多，超级大坑？

聪明的人的回答应该不是这三者中的任何一个，而是自己创建线程池。如果读者对Java中的阻塞队列有所了解的话，看到这里或许就能够明白原因了。

Java中的BlockingQueue主要有两种实现，分别是ArrayBlockingQueue 和 LinkedBlockingQueue。

ArrayBlockingQueue是一个用数组实现的有界阻塞队列，必须设置容量。

LinkedBlockingQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。

这里的问题就出在：

不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。也就是说，如果我们不设置LinkedBlockingQueue的容量的话，其默认容量将会是Integer.MAX_VALUE。而newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题OOM。

九、你在工作中是如何使用线程池的，是否自定义过线程池使用？

自定义线程池，以及api方式举例：

package com.juc.threadpool;

import java.util.concurrent.*;

/**
 * @program: acmPractice
 * @description: 线程池应用
 * @author: Mr.Li
 * @create: 2019-10-09 20:33
 **/
public class MyThreadPoolDemo {
    public static void main(String[] args) {
        //一池5个线程处理
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);

        //一池一线程
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();

        //一池n线程
        //ExecutorService threadPool = Executors.newCachedThreadPool();

        //自定义线程池
        ExecutorService threadPool = new ThreadPoolExecutor(2,5,1L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());  
               //4种拒绝策略.AbortPolicy,CallerRunsPolicy,DiscardPolicy,DiscardOldestPolicy
               //不同的策略方式，运行结果也将不一致

        //模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程
        for(int i = 1; i <= 10; i++) {
            threadPool.execute(()->{
                System.out.println(Thread.currentThread().getName() + "办理业务");
            });
        }

    }
}

十、合理配置线程池你是如果考虑的？

1、CPU 密集型

CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。

2、IO 密集型

由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2
也可以使用公式：CPU 核数 / (1 - 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。

扩展

十一、死锁编码以及定位分析

产生死锁的原因：

死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种相互等待的现象，如果无外力的干涉那它们都将无法推进下去，如果系统的资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。

代码体现：

package com.juc.deadlock;

import java.util.concurrent.TimeUnit;

/**
 * @description: 造成死锁的原因，如何排除
 * @author: Mr.Li
 * @create: 2019-10-10 15:53
 **/
class HoldLockThread implements Runnable {
    private String lockA;
    private String lockB;

    public HoldLockThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "\t自己持有" + lockA + "尝试获得" + lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "\t自己持有" + lockB + "尝试获得" + lockA);
            }
        }
    }
}

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new HoldLockThread(lockA,lockB),"AA").start();
        new Thread(new HoldLockThread(lockB,lockA),"BB").start();
    }
}

运行：程序始终未结束，并不知道发生什么错误

如何排查问题及相应解决：首先转到终端，输入命令 jsp -l 查出对应程序的进程号为 4184

然后输入命令：jstack 4184

可看到结果：发现一处死锁错误

Java stack information for the threads listed above:
===================================================
"BB":
        at com.juc.deadlock.HoldLockThread.run(DeadLockDemo.java:30)
        - waiting to lock <0x00000000d604bf88> (a java.lang.String)
        - locked <0x00000000d604bfc0> (a java.lang.String)
        at java.lang.Thread.run(Thread.java:748)
"AA":
        at com.juc.deadlock.HoldLockThread.run(DeadLockDemo.java:30)
        - waiting to lock <0x00000000d604bfc0> (a java.lang.String)
        - locked <0x00000000d604bf88> (a java.lang.String)
        at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

好了，也到尾声了，感谢你的观看，希望你尽快学会掌握喔！

每日一言：

生活就像海洋，只有一直坚强的人才能到达彼岸