JAVA并发编程之ThreadPool线程池技术的使用及深入理解

最新推荐文章于 2024-04-19 19:30:00 发布
最新推荐文章于 2024-04-19 19:30:00 发布
阅读量390 收藏 1
点赞数 1
分类专栏： Java并发编程 文章标签： java 多线程 并发编程 高并发 java高并发api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Code_artist_/article/details/112682620
版权

JAVA并发编程之ThreadPool线程池技术的使用及深入理解

1、线程池的简介

引用举例：
10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。
现在是多核电脑，多个线程各自跑在独立的CPU上，不用切换效率高。

线程池的特点：复用既有线程；控制最大线程并发数；管理线程资源。

线程池的优势：
线程池做的工作主要是控制运行的线程数量，如果线程数量超过了最大数量，超出数量的线程排队等候，等线程任务执行完毕，再从队列中取出任务来执行。

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

2、架构说明

Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，ExecutorService，ThreadPoolExecutor这几个类。

(1)Executor顶层接口
加粗样式

Executor接口是顶层接口，只有一个execute方法，过于简单。通常不使用它，而是使用ExecutorService接口。

(2)ExecutorService接口
**加粗样式**
(3)AbstractExecutorService抽象类和ThreadPookExecutor实现类
在这里插入图片描述

结构：顶层接口Executor（execute） --> 子接口ExecutorService（submit shutdown） --> 抽象类AbstractExecutorService --> 实现类ThreadPoolExecutor

在这里插入图片描述

那么问题来了，怎么创建一个连接池对象呢？通常使用Executors工具类

3、Executors工具类

架构图可以看到Executors工具类，有没有联想到Collections，Arrays等。没错，可以用它快速创建线程池。

List list = Arrays.asList("");
ExecutorService threadPool = Executors.newCachedThreadPool();

Executors类中的方法
在这里插入图片描述

直接编码演示：每种连接池的效果

(1)固定大小线程池

public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        //线程池的声明ExecutorService 底层接口只有一个声明方法太简单 ,所以使用executorService接口
        //固定大小线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            //线程池执行任务
            //可以把lambda表达式理解为简洁的匿名函数.
            //我们先声明一个函数式接口(函数式接口:就是只有一个抽象方法的接口.
            // lambda表达式和方法引用,只能用在函数式接口上),比较一下lambda表达式和匿名函数
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName()+"执行了任务");
                    });
        }
        //当任务执行完了不会立马销毁销毁,会等待新的任务过来,手动销毁线程池
        executorService.shutdown();
    }
}

在这里插入图片描述
(2)无限大小线程池

public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        //线程池的声明ExecutorService 底层接口只有一个声明方法太简单 ,所以使用executorService接口
        //固定大小线程池
        //ExecutorService executorService = Executors.newFixedThreadPool(5);
        //无限大小线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            //线程池执行任务
            //可以把lambda表达式理解为简洁的匿名函数.
            //我们先声明一个函数式接口(函数式接口:就是只有一个抽象方法的接口.
            // lambda表达式和方法引用,只能用在函数式接口上),比较一下lambda表达式和匿名函数
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName()+"执行了任务");
                    });
        }
        //当任务执行完了不会立马销毁销毁,会等待新的任务过来,手动销毁线程池
        executorService.shutdown();
    }
}

在这里插入图片描述
(3)单个大小的线程池

public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        //线程池的声明ExecutorService 底层接口只有一个声明方法太简单 ,所以使用executorService接口
        //固定大小线程池
        //ExecutorService executorService = Executors.newFixedThreadPool(5);
        //无限大小线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();
        //单个大小的线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100; i++) {
            //线程池执行任务
            //可以把lambda表达式理解为简洁的匿名函数.
            //我们先声明一个函数式接口(函数式接口:就是只有一个抽象方法的接口.
            // lambda表达式和方法引用,只能用在函数式接口上),比较一下lambda表达式和匿名函数
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName()+"执行了任务");
                    });
        }
        //当任务执行完了不会立马销毁销毁,会等待新的任务过来,手动销毁线程池
        executorService.shutdown();
    }
}

在这里插入图片描述
(4)定时任务线程池

public class ThreadPoolExecutorDemo {
    
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
        System.out.println("定时任务初始化时间" + System.currentTimeMillis());
        //固定周期执行
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            //System.currentTimeMillis()计算方式与时间的单位转换
            //延迟时间意义,需要矫正时间。
            System.out.println(Thread.currentThread().getName() + "定时任务执行了" + System.currentTimeMillis());
        }, 5, 10, TimeUnit.SECONDS);
        
        
//        scheduledExecutorService.schedule(() -> {
//            //System.currentTimeMillis()计算方式与时间的单位转换
//            System.out.println(Thread.currentThread().getName()+"定时任务执行了"+System.currentTimeMillis());
//        }, 10, TimeUnit.SECONDS);

    }
}

在这里插入图片描述工具类：Executors

  • newFixedThreadPool(线程数)：固定大小的线程池，阻塞队列是最大整型
  • newCachedThreadPool()：无限大小的线程池，最大可扩展线程数是最大整型
  • newSingleThreadExecutor()：单个大小的线程池，阻塞队列是最大整型
  • newScheduledThreadPool(线程数)：定时任务的线程池，最大可扩展线程数是最大整型

4、底层原理

上述案例中的四个方法的本质都是ThreadPoolExecutor的实例化对象，只是具体参数值不同。

4.1、线程池的7个重要参数

线程池的7个重要参数
在这里插入图片描述

  1. corePoolSize：核心线程数(线程池中的常驻核心线程数,有多少线程数)
  2. maximumPoolSize：最大可扩展线程数(线程池中能够容纳同时 执行的最大线程数，此值必须大于等于1,最大可扩展大小线程数）
  3. keepAliveTime：扩展线程数的空闲时间（多余的空闲线程的存活时间 当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到 只剩下corePoolSize个线程为止,扩展线程数的生存时间。）
  4. unit：keepAliveTime 时间的单位
  5. workQueue：阻塞任务队列 （被提交但尚未被执行的任务,候客区大小）
  6. threadFactory：表示生成线程池中工作线程的线程工厂( 用于创建线程，一般默认的即可)
  7. handler：拒绝执行处理器,拒绝策略(表示当队列满了，并且工作线程大于 等于线程池的最大线程数（maximumPoolSize）时，如何来拒绝 请求执行的runnable的策略)

4.2、线程池底层工作原理(面试概率极高)

具体流程：

重要的事情说三遍：以下重要：以下重要：以下重要：

  1. 线程池初始化之后,在创建了线程池后，线程池中的线程数为0。

  2. 向线程池提交一个任务,当调用execute()方法添加一个请求任务时，线程池会做出如下判断：

    1. 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；

    2. 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入阻塞队列；

    3. 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；

    4. 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。

(简述面试版本)

  • 1.线程池初始化之后，线程数为0
  • 2.向线程池提交一个任务进行execute，此时线程池底层会做出如下判断：
    • 1.判断核心线程数是否已满，未满创建新的核心线程处理该任务
    • 2.如果核心线程数已满，判断阻塞队列是否已满，未满则放入阻塞队列
    • 3.如果阻塞队列已满，判断最大可扩展性线程数是否已满，未满则创建新的非核心线程处理该任务
    • 4.如果最大可扩展线程数已满，执行拒绝策略
  • 3.一个任务执行完之后，线程会从阻塞队列中获取下一个任务执行
  • 4.一个线程如果空闲时间到达生存时间，依然要做出判断：判断当前线程数是否大于核心线程数，大于则销毁当前线程。直至核心线程数。

5、Executor工具类存在的问题

在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。

而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。

不推荐使用Executors工具类初始化线程池，因为他们都可能导致OOM。推荐使用ThreadPoolExecutor构造方法创建线程池
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

6、拒绝策略

一般我们创建线程池时，为防止资源被耗尽，任务队列都会选择创建有界任务队列，但种模式下如果出现任务队列已满且线程池创建的线程数达到你设置的最大线程数时，这时就需要你指定ThreadPoolExecutor的RejectedExecutionHandler参数即合理的拒绝策略，来处理线程池"超载"的情况。

ThreadPoolExecutor自带的拒绝策略如下：
例子:

  1. AbortPolicy(默认)：直接抛出RejectedExecutionException异常阻止系统正常运行
public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5));
        for (int i = 0; i < 20; i++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "执行了任务");
            });
        }

    }
}

在这里插入图片描述

  1. CallerRunsPolicy：“调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory(),new java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 20; i++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "执行了任务");
            });
        }

    }
}

在这里插入图片描述

  1. DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加人队列中 尝试再次提交当前任务。
public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0; i < 20; i++) {
            int finalI = i;
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "执行了任务"+ finalI);
            });
        }

    }
}

在这里插入图片描述

  1. DiscardPolicy：该策略默默地丢弃无法处理的任务，不予任何处理也不抛出异常。 如果允许任务丢失，这是最好的一种策略。
public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 0; i < 20; i++) {
            int finalI = i;
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "执行了任务"+ finalI);
            });
        }

    }
}

在这里插入图片描述

以上内置的策略均实现了RejectedExecutionHandler接口，也可以自己扩展RejectedExecutionHandler接口，定义自己的拒绝策略
在这里插入图片描述

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                (Runnable r, java.util.concurrent.ThreadPoolExecutor executor) ->{
                    System.out.println("执行了拒绝策略(自定义拒绝策略)");
                });
        for (int i = 0; i < 20; i++) {
            int finalI = i;
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "执行了任务"+ finalI);
            });
        }

    }
}

在这里插入图片描述

7、自定义线程池

自定义线程池：

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
    //自定义线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5));
        for (int i = 0; i < 20; i++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "执行了任务");
            });
        }

    }
}
RunningCodeMonkey
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
java线程池中任务执行完成后再次执行
yx9o
07-30 6278
最近做爬虫用到了线程池(我是创建一个固定线程数量的线程池,然后不断往里扔任务) 现在要求网站链接如果爬完后再次启动任务爬取链接,所以就想到在线程池中任务都执行完成后在重新启动任务. demo如下: public static void ex(Connection conn) throws InterruptedException{ UrlTask urlTask = new UrlTas
Java等线程池中的任务执行完之后再执行主线程之后的逻辑
flower_CSDN的博客
12-14 1272
JAVA,多线程，线程池
线程池 ThreadPoolExecutor 配置参数详解
最新发布
Huazie
04-19 1409
本篇 介绍 Java 中的线程池 ThreadPoolExecutor 配置参数
线程池ThreadPoolExecutor的七大参数
热门推荐
诗水人间
11-13 4万+
七个参数的构造方法如下 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnabl
线程阻塞队列
qq_39264897的博客
11-24 193
public class ConsumerProducerUsingBlockingQueue { //使用数组实现队列阻塞 private static ArrayBlockingQueue<Integer> buffer = new ArrayBlockingQueue<Integer>(2); public static void main(String[] args) { ExecutorService executor = Exe.
Java版线程池ThreadPool.zip
08-21
理解并合理使用Java线程池，能够有效地提升程序并发性能，减少资源消耗，同时降低编程复杂度，是Java并发编程中不可或缺的知识点。在实际项目开发中，应根据业务场景选择合适的线程池配置，并注意线程池的生命周期...
并发编程示例，涉及到AtomicXXX、CountDownLatch、线程池等
02-23
并发编程的一些小示例 1.等待通知的几种方式，包括Object的wait/notify,Condition的await/signal 2. CountDownLatch，统一控制多线程开始和结束 3.原子操作，AtomicXXX 4.线程池
java线程池threadpool简单使用源码
08-23
Java线程池（ThreadPool）是Java并发编程中的一个重要概念，它可以帮助我们有效地管理和控制并发执行的任务，从而提高系统的效率和稳定性。线程池通过复用已存在的线程，避免了频繁创建和销毁线程带来的开销，同时也...
Java多线程编程，生命游戏，用线程池.zip
09-10
通过这个项目，你可以深入理解Java多线程编程的实际应用，以及线程池的使用方法。同时，你还可以了解到如何将并发编程应用于简单的游戏设计，这有助于提升你在实际开发中的技能和经验。记得查看项目中的README.md...
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
java 调用其他线程_java 后台接口另起一个线程执行其他业务
weixin_39986060的博客
02-13 1021
直接post代码，然后在详细介绍为什么：packagecom.xxx.testset.service.impl;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/**** @function xxx接口实现类*@authorLiangjw* @date 2019-9-18 下午02:...
ThreadPoolExecutor主要参数？
weixin_43878297的博客
10-14 738
ThreadPoolExecutor3 个最重要的参数： corePoolSize：核心线程数，线程数定义了最小可以同时运行的线程数量。 maximumPoolSize：线程池中允许存在的工作线程的最大数量 workQueue：当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，任务就会被存放在队列中。 ThreadPoolExecutor其他常见参数: keepAliveTime：线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心...
多线程理解（二）
逝去的往事的博客
11-10 6206
线程安全的问题 关于线程安全问题，有一个经典的问题----银行取钱的问题。银行取钱的基本流程如下： 用户输入账户、密码，系统判断用户的账户、密码是否匹配； 用户输入取款金额； 系统判断账户余额是否大于取款金额； 如果余额大于取款金额，则取款成功；如果余额小于取款金额，则取款失败； 如果将这个流程放在多线程并发的场景下，就有可能出现问题； 同步代码块 为了解决这个问题，Java的多线程支持引入了...
使用Executors创建有10个线程的线程池
liangruilz的博客
09-15 1080
使用Executors创建有10个线程的线程池 package com.zr.demo01; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * 使用Executors创建有10个线程的线程池,该线程池的线程都是待机状态,所以避免了开启新线程的时间 * @auth...
Java并发包：ExecutorService和ThreadPoolExecutor
charming的专栏
07-12 1万+
文章译自：http://tutorials.jenkov.com/java-util-concurrent/index.html 抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正。 转自请注明出处。 ExecutorServiceJava.util.concurrent.ExecutorService接口代表一种异步执行机制，它能够在后台执行任务。因此ExecutorSer
JAVA线程池详解（ThreadPoolExecutor）
ChengHuanHuaning的博客
09-30 7613
随着计算机行业的飞速发展，摩尔定律逐渐失效，多核CPU成为主流。使用多线程并行计算逐渐成为开发人员提升服务器性能的基本武器。如果你要成为一个好的工程师，还是得比较好地掌握这个知识，很多线上问题都是因为没有用好线程池导致的。即使你为了谋生，也要知道，这基本上是面试必问的题目，而且面试官很容易从被面试者的回答中捕捉到被面试者的技术水平。
Java高并发(四)——ThreadPool，线程复用
学会改变自己——才能突破
11-25 1万+
        前边我们讲述了：Java高并发——了解并行世界、Java高并发——多线程基础、Java高并发——多线程协作，同步控制 。从1，线程是什么？为什么需要多线程？2，Java对多线程的基础操作：线程的状态扭转，线程的创建、终止、中断、等待和通知、挂起和执行、等待结束和谦让，volatile关键字，线程组进行分类管理，守护线程，线程优先级，线程共享资源安全和synchronized进行控制...
Muduo之封装CurrentThread、Thread、ThreadPool
一个菜鸟的博客
02-09 548
基础知识 1、CurrentThread 2、Thread 3、ThreadPool 大多数的网络服务器，包括Web服务器都具有一个特点，就是单位时间内必须处理数目巨大的连接请求，但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的：一旦有个请求到达，就创建一个新的线程，由该线程执行任务，任务执行完毕之后，线程就退出。这就是”即时创建，即时销毁”的策略。尽管与创建进程相比，...
92道Java多线程与并发面试题含答案（很全）
01-03
"Java并发编程是Java开发中的关键领域，涉及到多线程、进程、并发控制、线程间通信和线程池等多个概念。本文提供了一份详细的Java多线程与并发面试题集，旨在帮助开发者深入理解并掌握相关知识。" 在Java中，多线程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值