【JavaEE精炼宝库】多线程（6）线程池

2024-06-16 13:44
文章标签 java 线程 多线程 ee 精炼 宝库

本文主要是介绍【JavaEE精炼宝库】多线程（6）线程池，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

一、线程池的概念及优势

1.1 线程池的概念：

1.2 线程池的优势：

二、工厂模式

三、标准库中的线程池

3.1 标准库线程池参数解释：

3.1.1 corePoolSize | maximumPoolSize：

3.1.2 keepAliveTime | unit：

3.1.3 workQueue： 

3.1.4 ThreadFactory： 

3.1.5 handler：

3.2 创建线程池演示：

3.3 利用线程池的工厂类来创建线程池：

3.4 线程池的使用演示：

四、线程池的实现

一、线程池的概念及优势

1.1 线程池的概念：

线程池是一种并发编程的技术，它维护着一组预先创建的线程，以便在需要时重用它们来执行多个任务。这可以提高程序的性能和效率，因为线程的创建和销毁通常是昂贵的操作，通过重用线程，可以减少这种开销。

在我们前面已经介绍了线程比进程更加轻量，在频繁创建销毁的时候，线程更有优势。但是随着时代的发展，对于 “频繁” 有了新的定义（比如之前 1 万就认为是频繁，但是现在可能 1000 万才认为是频繁）。即使是线程，在如此频繁的创建和销毁的情况下，开销也变得难以接受。

那么要怎么优化呢？

答：我们可以通过线程池和协程进行优化。

协程这里我们暂且不进行描述，Go 语言主打的卖点就是使用协程处理并发编程。线程池的优化我们马上讲到。

1.2 线程池的优势：

• 降低资源消耗：

减少线程的创建和销毁带来的性能开销。

• 提高响应速度：

当任务来时可以直接使用，不用等待线程创建

• 可管理性：

进行统一的分配，监控，避免大量的线程间因互相抢占系统资源导致的阻塞现象。

二、工厂模式

在下面即将介绍的线程池参数中，其中有一个参数是工厂类。所以在这里提前给大家解释一下什么是工厂模式。

工厂模式：也是一种设计模式，主要解决的问题是构造方法创建对象太坑了的问题。为什么说构造方法创建对象有坑呢？举个栗子：

因为在 Java 的语法中要求构造方法的命名必须是类名且参数类型和个数，排列顺序不能一样。这就导致遇到上面这种案例解决不了。就需要工厂模式，核心思路，不使用构造方法创建对象，给构造方法包装一层。例如下面这段代码：这只是个伪代码，看看思路就行，makePointByXY 这样的方法就叫 “工厂方法”，这样写代码的套路就叫做 “工厂模式”，没有什么特别的。

public class Point {public static Point makePointByXY(double x,double y){Point p = new Point();p.setX(x);//和 setR 是有区别的，比如传给的函数不一样p.setY(y);return p;}public static Point makePointByRA(double r,double a){Point p = new Point();p.setR(r);p.setA(a);return p;}
}

工厂类的写法如下图： 工厂方法用单独的类来进行提供。

如果语法层面上，不强制要求构造方法名字必须和类名一致，就没有上述模式的必要了。

三、标准库中的线程池

3.1 标准库线程池参数解释：

ThreadPoolExecutor：

使用起来比较复杂，在其构造方法中，包含很多的参数。（面试考点）例如下面这个就是包含全部参数的构造方法，了解这个了，其他的就都会了，下面会围绕这个构造方法参数进行解释。

3.1.1 corePoolSize | maximumPoolSize：

在 Java 的标准库中线程池把线程分成两类：1. 核心线程。2. 非核心线程。

顾名思义 corePoolSize 就是核心线程数，maximumPoolSize 就是最大线程数（核心线程数 + 非核心线程数）。

这里就涉及到动态扩展的概念，在线程池刚开始就会创建出核心线程数的线程（最小线程数），随着项目的进行，如果添加的任务比较多的话，核心线程数处理不过来了（有很多任务在队列中，排队等待执行），这个时候线程池就会自动的创建出新的线程，来支撑更多的任务。但是，创建出来的线程总数不能超过最大线程数（maximumPoolSize），过了一段时间，任务没有那么多了，线程 “清闲下来” 这时部分非核心线程就会被释放掉，线程池中会保证线程数目不少于核心线程数。

这样就既可以保证任务多的时候的效率，也能保证任务少的时候，系统的开销。到这里就又有了一个问题：

在实际开发中，线程数应该设置成多少合适呢？

答：只要是具体的数字，答案一定是错误的。我们要根据实验的方式，对程序进行性能测试，测试过程中，设定不同的线程池的数值。最终根据实际程序的响应速度和系统开销，综合权衡，找到一个合适值。

这不仅仅和电脑的配置有关（有多个 CPU 核心），更重要的是，和我们的程序的实际特点有关系。极端情况下可以分为两大类：

• CPU 密集型程序：代码完成的逻辑，都是要通过 CPU 来完成的.（此时的性能瓶颈是 CPU）。此时线程的数量是不应该超过 CPU 逻辑核心数的。

• IO 密集型程序：代码大部分时间在等待 IO（等待 IO 是不消耗 CPU，不参与调度）。此时瓶颈就不在 CPU 上，我们更多考虑其他方面（比如网络程序，要考虑网卡宽带的瓶颈）。

3.1.2 keepAliveTime | unit：

• keepAliveTime：

表示非核心线程，允许空闲的最大时间。也就是说非核心线程在线程池 ”不忙“ 的时候不是马上回收掉。

• unit：

TimeUnit：这是一个枚举类型。其中的枚举常量有：

3.1.3 workQueue： 

阻塞队列我们上一篇文章已经自己实现过了，这里利用阻塞队列要存储 Runnable 对象也就是要执行的任务。线程池会提供 submit 方法，让其他线程把任务提交给线程池。其他线程会 submit 任务到这个队列中，这个队列存的元素就是 Runnable 对象，要执行的逻辑就是 run 方法里面的内容。

3.1.4 ThreadFactory： 

ThreadFactory：是标准库中提供的，用来创建线程的工厂类。这个线程工厂，主要是为了批量的给创建的线程设置一些属性， 线程工厂在它的工厂方法中，把线程的属性提前初始化好了。至于什么是工厂类，在上面的工厂模式那里已经解释过了，这里就不再赘述。

3.1.5 handler：

面试官问线程池的参数都是什么意思？其实就是在考我们对于这个参数的理解，前面 6 个都是添头。注意：此处 Handler 不是句柄的意思（句柄的术语也是 Handler）。

这里可以理解为拒绝策略，如果当前任务队列满了，仍要继续添加任务，咋办呢？直接阻塞其实不太合适。所以这里多了一个拒绝策略的参数。

幸运的是，我们 Java 的大佬已经给我们实现了四种常用的拒绝策略，在 ThreadPoolExecutor 类的里面，有四种静态内部类，列举如下：

对上面四种拒接策略的简单翻译如下：

 • AbortPolicy()：超过负荷，直接抛出异常。

 • CallerRunsPolicy()：调用者负责处理多出来的任务。

 • DiscardOldestPolicy()：丢弃队列中最老的任务。

 • DiscardPolicy()：丢弃新来的任务。

3.2 创建线程池演示：

这里唯一有些难度的就是拒绝策略的创建，在 ThreadPoolExecutor 类中有四个内部类实现了 RejectedExecutionHandler 接口。具体代码如下：

简单的编写如下： 

import java.util.concurrent.*;
public class demo3 {public static void main(String[] args) {BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(5);//阻塞队列ThreadFactory factory = new ThreadFactory() {//工厂模式@Overridepublic Thread newThread(Runnable r) {return new Thread(r);//这里就可以对 Thread 设置一些参数}};RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();//拒绝策略，注意这里是调用 ThreadPoolExecutor 的静态内部类ThreadPoolExecutor pool = new ThreadPoolExecutor(3,6,100,TimeUnit.DAYS,queue,factory,handler);}
}

3.3 利用线程池的工厂类来创建线程池：

使用线程池的工厂类来创建线程池的方法一共有 6 种，其中我们重点理解下面给出的四种即可。

工厂类为：Executors ，这里产生的线程池为 ExecutorService 类。具体如下图：

可以看到官方提供的创建线程池的工厂方法还是很多的。我们主要理解下面这四个即可。

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class demo1 {public static void main(String[] args) {//能够根据任务数量，自动进行线程扩容的线程池ExecutorService sevice1 = Executors.newCachedThreadPool();//创建固定线程数目的线程池ExecutorService service2 = Executors.newFixedThreadPool(4);//创建只包含单个线程的线程池ExecutorService service3 = Executors.newSingleThreadExecutor();//创建固定数目的线程个数，但是任务延时执行的线程池ExecutorService service4 = Executors.newScheduledThreadPool(4);}
}

Executors 创建线程池的几种方式：

• newFixedThreadPool：创建固定线程数的线程池。

• newCachedThreadPool：创建线程数目动态增长的线程池。

• newSingleThreadExecutor：创建只包含单个线程的线程池。

• newScheduledThreadPool：设定延迟时间后执行命令，或者定期执行命令。

Executors 本质上是 ThreadPoolExecutor 类的封装。 

3.4 线程池的使用演示：

 我们可以利用 submit 来进行添加任务（每个都必须实现 Runnable 接口）。

import java.util.concurrent.*;
public class demo1 {public static void main(String[] args) {ExecutorService service1 = Executors.newCachedThreadPool();for(int i = 1;i <= 1000;i++){int id = i;//这里必须要使用 id 来接受 iservice1.submit(new Runnable() {//匿名内部类@Overridepublic void run() {System.out.println(id +" , " + Thread.currentThread().getName());//必须只能打印 id，打印 i 会报错//报错的原因为：变量捕捉}});}}
}

案例演示的结果如下：

至于剩下三个线程池都是一样的，这里就不过多赘述了。 如果只是简单的使用一下，就直接用工厂类即可，如果希望更加精细的控制，就使用原生的 ThreadPoolExecutor。所以 Java 标准库线程池的创建方式一共有 7 种。

四、线程池的实现

为了更加深入的理解线程池的使用，这里我们就来简单的实现一个简易的线程池。我们要实现的东西有1. 若干线程。2. 任务队列。3. 提供 submit 方法。

我们可以利用 ArrayList 来存储线程，利用阻塞队列来辅助完成线程池，创建一个能自动扩容的线程池，每个线程的任务就是不停的去阻塞队列中取元素然后执行。剩下的一些在代码中都有注释。

代码实现如下：

import java.util.concurrent.*;
import java.util.*;
//自己实现一个线程池
class MyThreadPool{//1. 线程private int corePoolSize;//核心线程数private int maximumPoolSize;//最大线程数private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(1000);private List<Thread> threads = new ArrayList<>();//存储线程public MyThreadPool(int coreThreadSize,int maximumPoolSize) throws InterruptedException {this.corePoolSize = coreThreadSize;this.maximumPoolSize = maximumPoolSize;for(int i = 0;i < coreThreadSize;i++){Thread t = newThread();t.start();threads.add(t);}}private Thread newThread(){//每个线程的任务就是不停的执行队列中的元素Thread t = new Thread(() -> {while(true){try {Runnable task = queue.take();task.run();} catch (InterruptedException e) {throw new RuntimeException(e);}}});return t;}//2. 阻塞队列//3. submit 方法public void submit(Runnable task) throws InterruptedException {queue.put(task);//如果队列中的元素大于一个阈值，且线程数小于最大线程数时，就可以创建新的线程来帮助，处理队列中的元素if(queue.size() >= 50 && threads.size() < maximumPoolSize){//创建 线程Thread t = newThread();t.start();threads.add(t);}}
}
public class demo3 {public static void main(String[] args) throws InterruptedException {MyThreadPool threadPool = new MyThreadPool(4,50);for(int i = 0;i < 10000;i++) {int id = i;threadPool.submit(new Runnable(){@Overridepublic void run(){System.out.println("hello " + id + " ," + Thread.currentThread().getName());}});}}
}

具体效果如下：

如果要实现拒绝策略的话，也是在 submit 这里实现。 

结语：

其实写博客不仅仅是为了教大家，同时这也有利于我巩固知识点，和做一个学习的总结，由于作者水平有限，对文章有任何问题还请指出，非常感谢。如果大家有所收获的话还请不要吝啬你们的点赞收藏和关注，这可以激励我写出更加优秀的文章。

这篇关于【JavaEE精炼宝库】多线程（6）线程池的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1066607。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
在cscode中通过maven创建java项目

在cscode中通过maven创建java项目

在cscode中创建java项目 可以通过博客完成maven的导入 建立maven项目 使用快捷键 Ctrl + Shift + P 建立一个 Maven 项目 1 Ctrl + Shift + P 打开输入框2 输入 "> java create"3 选择 maven4 选择 No Archetype5 输入 域名6 输入项目名称7 建立一个文件目录存放项目，文件名一般为项目名8 确定
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2