🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈

回顾这期内容:【多线程】线程池，介绍了线程池，其中 5.3 介绍如何给线程池设置合适线程数量（这期内容会再回顾一遍），这期内容，具体讨论一下，线程池核心数到底如何配置~

1. 前置回顾

在实际开发中如何给线程池设置合适的线程数量呢？

我们要知道，线程不是越多越好，线程的本质上是要在 CPU 上调度的，一个线程池的线程数量设置为多少合适，这需要结合实际情况实际任务决定，一般分为 CPU 密集型和 IO 密集型，通常是如下配置：

1. CPU 密集型任务：N+1，主要做一些计算工作，要在 CPU上运行
2. IO 密集型任务：2N+1，主要是等待 IO 操作，比如等待读写硬盘，读写网卡等，不怎么消耗 CPU 资源
   (其中 N 为 CPU 的核心数量)

Q：为什么要加 1

A：+1 个线程是为了在某个线程因为一些原因，比如缓存未命中、遇到短暂的指令停顿等，暂时阻塞时，能有一个额外的线程可以在 CPU 上运行，从而充分利用 CPU 的空闲时间，避免 CPU 核心出现空闲等待的情况，提高整体的 CPU 利用率，应对一些特殊情况或系统开销等，确保即使在某些线程出现意外阻塞等情况时，系统仍能有额外的线程来维持一定的处理能力，保证系统的稳定性和性能

极端情况下，如果线程全是使用 CPU 运行，线程数就不应该超过 CPU 核心数（逻辑核心，比如一个电脑是6核12线程，即12个逻辑核心，以12为基准），如果线程全是使用的 IO，则线程数可以设置很多，远远超出 CPU 的核心数

在实际开发中，很少有这么极端的情况，就是以实际情况来设定，需要具体通过测试的方式来确定，测试方式的大体思路是，运行程序，通过记录时间戳计算一下执行时间，同时监测资源的使用状态，线程数量取一个执行效率可以并且占用资源也还可以的数量~

这里的两个关键点：

• 记录时间戳计算执行时间
• 监测资源的使用状态

计算执行时间的具体操作方法是，可以统计一个完整的请求中，耗费 CPU 计算的过程占用了多少时间，等待的过程，如读取缓存、读取 DB 等占用了多少时间，假设统计结果是 100ms 用来做 CPU 计算，900ms 都是 IO 相关的操作，不占 CPU 时间，那么就可以通过 (100+900) / 100 的计算公式，得出对于单核 CPU，设置线程数为 10 就可以把 CPU 跑满，同理，如果是 6 核 CPU，那么就设置线程数为 60

监测资源的使用状态具体操作方法，在程序执行过程中，持续监测 CPU、内存、线程等资源的使用情况

具体代码如下：

java">import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ResourceMonitoringExample {// 这里进行模拟任务static class Task implements Runnable {@Overridepublic void run() {try {// 模拟耗时操作Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {int threadCount = 10; // 初始线程数量ExecutorService executor = Executors.newFixedThreadPool(threadCount);// 记录开始时间long startTime = System.currentTimeMillis();// 提交任务for (int i = 0; i < 20; i++) {executor.submit(new Task());}// 关闭线程池executor.shutdown();while (!executor.isTerminated()) {// 监测资源使用状态monitorResources();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}// 记录结束时间long endTime = System.currentTimeMillis();long executionTime = endTime - startTime;System.out.printf("程序执行时间: %d 毫秒%n", executionTime);}// 监测资源使用状态private static void monitorResources() {// 监测 CPU 使用情况OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();if (osBean instanceof com.sun.management.OperatingSystemMXBean) {com.sun.management.OperatingSystemMXBean sunOsBean = (com.sun.management.OperatingSystemMXBean) osBean;double cpuLoad = sunOsBean.getSystemCpuLoad();if (cpuLoad >= 0) {System.out.printf("当前系统 CPU 使用率: %.2f%%%n", cpuLoad * 100);}}// 监测线程数量ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();int threadCount = threadBean.getThreadCount();System.out.printf("当前活动线程数量: %d%n", threadCount);}
}

其中：ManagementFactory 是 Java 中的一个实用工具类，位于 java.lang.management 包下，该类提供了一系列静态方法，用于获取 JVM 的各种管理接口实例，这些管理接口允许你监控和管理 JVM 的运行时状态、系统资源使用情况等（后文会详细介绍）~

总结：

线程池的核心参数并不是这么冰冷冷且固定的数字，还是需要结合实际场景考虑，一般线程池核心数，可以根据实际情况进行计算后配置~

下面介绍动态线程池，我们一起来看看~

2. 动态线程池

线程池线程数的设置是个难题，线程池核心数到底如何配置？最好的办法是能够动态调整线程池线程数，并能够看到调整后的效果，也就是线程利用率，有一个工具能够实现这样的效果 —— 使用 JMX

那么 JMX 是什么呢？ 我们先来一起了解一下！

2.1 JMX 的介绍

1. JMX 是什么：JMX（Java Management Extensions）是 Java 平台的一部分，它提供了一种管理和监控 Java 应用程序的标准方法，即是一个为应用程序、设备、系统等植入管理功能的框架，JMX 允许监控和管理系统资源、应用程序和服务，以及获取关于这些实体的运行时信息，简单来说，就是通过 JMX 可以动态查看对象的运行信息，并且可以动态修改对象属性~
2. JMX 的架构：如下图
   

分析这张图我们可以发现，JMX 底层是由很多不同的 MBeans 组成的，即 MBeans 是 JMX 的核心

2.1.1 MBeans 介绍

MBeans 是什么：它们是实现了特定接口的 Java 对象，用于表示可以被监控和管理的资源

MBeans 的类型：可以分为四种不同的类型

• Standard MBeans
• Dynamic MBeans
• Open MBeans
• Model MBeans

MBeans 的作用：这些 MBeans 的作用就是获取对象的信息，或是修改对象信息，都是通过 MBeans 来完成的

MBeans 的用法：所有的 MBeans 都需要注册到 MBeanServer 上，然后再通过一些外部工具如 JMX、Web 浏览器等，就可以去获取或者修改 MBeans 的信息了

补充：
Q：那 MBean Server 是什么呢？
A：这里的 MBean Server 是一个代理，它提供一个注册、检索和操作 MBeans 的 API，它是 JMX 架构中的核心组件，负责管理所有 MBeans 的生命周期

接下来，我们一起来看看如何使用 JMX 诗仙女动态修改线程池

2.2 使用 JMX + jconsole 实现动态修改线程池

1）自定义一个动态线程池

首先，我们先来自定义一个动态线程池，如下：

java">import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** Created with IntelliJ IDEA.* Description:* User: 26727* Date: 2025-02-05* Time: 18:41*/
public class DynamicThreadPool {private ThreadPoolExecutor threadPoolExecutor;public DynamicThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);}public ThreadPoolExecutor getThreadPoolExecutor() {return threadPoolExecutor;}public void setCorePoolSize(int corePoolSize) {threadPoolExecutor.setCorePoolSize(corePoolSize);}public void setMaximumPoolSize(int maximumPoolSize) {threadPoolExecutor.setMaximumPoolSize(maximumPoolSize);}
}

动态线程池的相关参数如下，动态线程池其实就是传统的线程传统的线程池对象 ThreadPoolExecutor 封装了一下，并且提供了两个方法 setCorePoolSize 和 setMaximumPoolSize，这样通过这两个方法，我们就可以动态设置线程池的线程数了~

2）自定义一个 MBean 接口

接下来，我们自定义一个 MBean 这个接口中提供四个方法，分别用来获取或者设置线程数的信息

java">public interface DynamicThreadPoolMXBean {int getCorePoolSize();void setCorePoolSize(int corePoolSize);int getMaximumPoolSize();void setMaximumPoolSize(int maximumPoolSize);
}

3）自定义类实现 DynamicThreadPoolMXBean 接口

接着，我们自定义类实现 DynamicThreadPoolMXBean 接口，并继承 StandardMBean 类，如下：

java">import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.StandardMBean;
import java.lang.management.ManagementFactory;/*** Created with IntelliJ IDEA.* Description:* User: 26727* Date: 2025-02-04* Time: 23:02*/
public class DynamicThreadPoolMBean extends StandardMBean implements DynamicThreadPoolMXBean {private DynamicThreadPool dynamicThreadPool;public DynamicThreadPoolMBean(DynamicThreadPool dynamicThreadPool) throws Exception {super(DynamicThreadPoolMXBean.class);this.dynamicThreadPool = dynamicThreadPool;registerMBean();}private void registerMBean() {try {MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();ObjectName name = new ObjectName("org.javaboy:type=DynamicThreadPool");mbs.registerMBean(this, name);} catch (Exception e) {e.printStackTrace();}}@Overridepublic int getCorePoolSize() {return dynamicThreadPool.getThreadPoolExecutor().getCorePoolSize();}@Overridepublic void setCorePoolSize(int corePoolSize) {dynamicThreadPool.setCorePoolSize(corePoolSize);}@Overridepublic int getMaximumPoolSize() {return dynamicThreadPool.getThreadPoolExecutor().getMaximumPoolSize();}@Overridepublic void setMaximumPoolSize(int maximumPoolSize) {dynamicThreadPool.setMaximumPoolSize(maximumPoolSize);}
}

【解析】

• 构造函数接受一个 DynamicThreadPool 类型的参数，用于初始化 dynamicThreadPool 的成员变量
  super(DynamicThreadPoolMXBean.class) 调用父类 StandardMBean 的构造函数，传入 DynamicThreadPoolMXBean 类的 Class 对象，用于指定 MBean 的管理接口，调用 registerMBean() 方法将该 MBean 注册到 JMX 平台 MBean 服务器中，即在构造器中，调用了 registerMBean() 方法，这个方法用来将当前对象注册到 MBeanServer 上~

• 注册 MBean 方法 registerMBean()，ManagementFactory.getPlatformMBeanServer() 获取平台 MBean 服务器的实例，ObjectName 用于唯一标识 MBean，这里使用 org.javaboy:type=DynamicThreadPool 作为 MBean 的名称，
  mbs.registerMBean(this, name) 将当前 DynamicThreadPoolMBean 实例注册到 MBean 服务器中

4）执行代码

最后，就可以启动自己的这段代码了~

java">import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;/*** Created with IntelliJ IDEA.* Description:* User: 26727* Date: 2025-02-04* Time: 23:07*/
public class Main {public static void main(String[] args) throws Exception {DynamicThreadPool dynamicThreadPool = new DynamicThreadPool(2, 6, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(10));DynamicThreadPoolMBean mBean = new DynamicThreadPoolMBean(dynamicThreadPool);while (true) {System.out.println("CorePoolSize:"+dynamicThreadPool.getThreadPoolExecutor().getCorePoolSize());System.out.println("MaximumPoolSize:"+dynamicThreadPool.getThreadPoolExecutor().getMaximumPoolSize());try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

为了看到线程池的线程数量，这里使用了一个死循环一直打印线程数量信息，这样一会通过 jconsole 修改线程池信息的时候，就能看到修改的效果了~

程序启动之后，使用 jconsole 连接上当前应用程序，如下图：

（jconsole 使用忘记的小伙伴可回顾往期内容：【多线程】如何使用jconsole工具查看Java线程的详细信息？）

点击 Main 进入连接

点击 MBean 这个选项卡位置，可以看到刚刚配置的 MBean，右侧的值则可以点击直接修改，修改之后，回到应用程序控制台，可以发现线程相关数据已经发生变化了，实现了动态修改的效果~

可以看到，控制台信息已经发生变化，如下：

这样就可以动态修改了！

2.2.1 介绍 ManagementFactory

可以看到上面使用了 ManagementFactory 类，下面具体介绍其用法：

1） 获取线程管理接口实例 —— getThreadMXBean()

返回一个 ThreadMXBean 实例，用于监控和管理 Java 虚拟机中的线程，通过该接口，可以获取线程的各种信息，如线程的状态、CPU 时间、阻塞时间等

java">import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;public class ThreadMonitoringExample {public static void main(String[] args) {// 获取 ThreadMXBean 实例ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();// 获取所有线程的 IDlong[] threadIds = threadMXBean.getAllThreadIds();for (long threadId : threadIds) {// 获取线程信息System.out.println("Thread ID: " + threadId + ", Thread Name: " + threadMXBean.getThreadInfo(threadId).getThreadName());}}
}

2）获取内存管理接口实例 —— getMemoryMXBean()

返回一个 MemoryMXBean 实例，用于监控和管理 Java 虚拟机的内存使用情况。通过该接口，可以获取堆内存和非堆内存的使用情况，还可以触发垃圾回收操作~

java">import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;public class MemoryMonitoringExample {public static void main(String[] args) {// 获取 MemoryMXBean 实例MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();// 获取堆内存使用情况MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();System.out.println("Heap Memory Usage: " + heapMemoryUsage);// 获取非堆内存使用情况MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();System.out.println("Non-Heap Memory Usage: " + nonHeapMemoryUsage);}
}

3）获取运行时管理接口实例 —— getRuntimeMXBean()

返回一个 RuntimeMXBean 实例，用于获取 Java 虚拟机的运行时信息，如 JVM 的启动时间、系统属性、命令行参数等

java">import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;public class RuntimeInfoExample {public static void main(String[] args) {// 获取 RuntimeMXBean 实例RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();// 获取 JVM 启动时间long startTime = runtimeMXBean.getStartTime();System.out.println("JVM Start Time: " + startTime);// 获取系统属性System.out.println("System Properties: " + runtimeMXBean.getSystemProperties());}
}

ManagementFactory 类为 Java 开发者提供了便捷的方式来监控和管理 JVM 的运行时状态，通过获取不同的管理接口实例，可以深入了解 JVM 的内部运行情况，从而进行性能调优、故障排查等相关工作~

2.2.2 JMX 与 ManagementFactory 的区别与联系

区别：

JMX —— Java 扩展管理，是一个为应用程序、设备、系统等植入管理功能的框架

ManagementFactory —— Java 标准库中用于辅助使用 JMX 功能的实用工具类

联系：

• ManagementFactory 是 JMX 功能使用的便捷入口
  JMX 架构复杂：JMX 定义了一套完整的架构，包括 MBean、MBeanServer等核心组件，使用 JMX 进行管理和监控时，需要涉及多个步骤和类的使用，整体较为复杂，而 ManagementFactory 简化操作，ManagementFactory 类提供了一系列静态方法，通过调用这些方法可以方便地获取各种 JMX 管理接口的实例。如，ManagementFactory.getThreadMXBean() 方法返回的 ThreadMXBean 是一个 JMX 的 MXBean，它允许开发者监控和管理 Java 虚拟机中的线程。这些方法隐藏了底层 JMX 架构的复杂性，使得开发者可以更轻松地使用 JMX 功能~
• ManagementFactory 实例基于 JMX 标准
  ManagementFactory 所返回的各种管理接口实例（如 MemoryMXBean、RuntimeMXBean 等）都是遵循 JMX 规范的 MXBean，这些 MXBean 定义了一组标准的管理操作和属性，可以通过 JMX 代理进行访问和管理，并且可集成到 JMX 系统，通过 ManagementFactory 获取的管理接口实例可以无缝集成到 JMX 系统中。开发者可以将这些 MXBean 注册到 MBeanServer 上，然后使用 JMX 客户端远程或本地监控和管理 Java 应用程序~
• ManagementFactory 服务于 JMX 监控和管理目的
  支持监控：JMX 的主要目的之一是对 Java 应用程序进行监控和管理，ManagementFactory 所提供的各种管理接口实例可以提供丰富的监控数据，例如，MemoryMXBean 可以提供 Java 虚拟机的内存使用情况，包括堆内存和非堆内存的使用量、峰值等信息；并且ThreadMXBean 可以提供线程的状态、CPU 时间等信息。
  支持管理：除了监控数据，ManagementFactory 所提供的管理接口实例还支持一些管理操作，例如，MemoryMXBean 可以触发垃圾回收操作，ThreadMXBean 可以获取线程的堆栈跟踪信息等，这些操作可以帮助开发者对 Java 应用程序进行动态管理和故障排查~

💛💛💛本期内容回顾💛💛💛

✨✨✨本期内容到此结束啦~