【多线程】线程池核心数到底如何配置？

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

在这里插入图片描述

文章目录

1. 前置回顾
2. 动态线程池
- 2.1 JMX 的介绍
- - 2.1.1 MBeans 介绍
- 2.2 使用 JMX + jconsole 实现动态修改线程池
- - 2.2.1 介绍 ManagementFactory
  - 2.2.2 JMX 与 ManagementFactory 的区别与联系

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

1. 前置回顾

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

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

CPU 密集型任务：N+1，主要做一些计算工作，要在 CPU上运行
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、内存、线程等资源的使用情况

具体代码如下：

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 {
        @Override
        public 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 的介绍

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

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

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 这个接口中提供四个方法，分别用来获取或者设置线程数的信息

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

3）自定义类实现 DynamicThreadPoolMXBean 接口

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

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();
        }
    }

    @Override
    public int getCorePoolSize() {
        return dynamicThreadPool.getThreadPoolExecutor().getCorePoolSize();
    }

    @Override
    public void setCorePoolSize(int corePoolSize) {
        dynamicThreadPool.setCorePoolSize(corePoolSize);
    }

    @Override
    public int getMaximumPoolSize() {
        return dynamicThreadPool.getThreadPoolExecutor().getMaximumPoolSize();
    }

    @Override
    public 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）执行代码

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

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 时间、阻塞时间等

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;

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

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

返回一个 MemoryMXBean 实例，用于监控和管理 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 的启动时间、系统属性、命令行参数等

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 应用程序进行动态管理和故障排查~

在这里插入图片描述