任务场景:分别实现"两级并发"模型:100 个上级执行单元,每个上级单元再启动 100 个子执行单元,子单元模拟 1 秒的数据库 I/O 等待。用于对比Java和Go在高并发场景下的实现方式与执行效率。

代码环境:Go 1.22.0、JDK-1.8、JDK-21, 电脑硬件:CPU R5-5600、内存16G、Win11

测试结果:

  1. Go goroutine 最快最省内存 :耗时最短(1067ms),堆内存最少(5.88MB)
  2. Java 虚拟线程接近 Go :1592ms、27MB,和 Go 差距不大
  3. Java 线程池瓶颈明显 :5218ms、32MB,受限于 OS 线程数,再加大线程数收益递减;5000 线程已是最优;4000 和 5000 耗时相同

测试过程:

Go

// go 1.22 [初始代码来自AI]
package main

import (
	"fmt"
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

// ========== 常量配置 ==========

const (
	supervisorCount = 100                    // 上级 goroutine 数量(第一级)
	workerCount     = 100                    // 每个上级下的 worker goroutine 数量(第二级)
	sleepDuration   = 1 * time.Second        // 模拟 I/O 操作的 sleep 时长
	sampleDelay     = 500 * time.Millisecond // 采样延迟(备用,当前用轮询)
)

// main 函数:程序入口
//
// 执行流程:
//  1. 创建两级 goroutine(上级 + worker),但都在"启动栅栏"前停下
//  2. 轮询等待所有 worker goroutine 都准备好
//  3. 全并发时采样内存和 goroutine 数(峰值状态)
//  4. 打开栅栏,所有 goroutine 同时开始执行
//  5. 等待所有任务完成
//  6. 打印统计信息
func main() {
	// 记录开始时间
	startTime := time.Now()

	// ========== 启动栅栏机制 ==========
	// 目的:让所有 goroutine 都启动后再同时开始,
	//       这样我们才能在"全并发"的状态下采样峰值数据。

	// 已就绪的 worker 计数(原子操作,线程安全)
	var readyCount atomic.Int32
	// 启动栅栏:所有 goroutine 启动后在这等着,等我们采样完才放行
	var startGate sync.WaitGroup
	startGate.Add(1) // 栅栏初始是关闭的(计数器=1)

	// 上级 goroutine 的 WaitGroup:等所有上级都完成
	var supervisorWg sync.WaitGroup

	// ========== 第一步:启动所有上级 goroutine ==========
	for i := 0; i < supervisorCount; i++ {
		supervisorWg.Add(1)
		// 启动一个上级 goroutine
		go func(supervisorID int) {
			// 上级 goroutine 结束时,把自己的计数减一
			defer supervisorWg.Done()

			// 这个上级下所有 worker 的 WaitGroup
			var workerWg sync.WaitGroup

			// ========== 第二步:每个上级启动 N 个 worker ==========
			for j := 0; j < workerCount; j++ {
				workerWg.Add(1)
				// 启动一个 worker goroutine
				go func(workerID int) {
					// worker 结束时,把自己的计数减一
					defer workerWg.Done()

					// 告诉主线程:我准备好了
					readyCount.Add(1)
					// 在栅栏前等着,等主线程说"开始"再往下走
					startGate.Wait()
					// 模拟 1 秒的 I/O 操作(数据库查询、HTTP 调用等)
					// goroutine 的 sleep 由 Go runtime 管理,不会阻塞 OS 线程
					time.Sleep(sleepDuration)
				}(j)
			}

			// 等这个上级下的所有 worker 都完成
			workerWg.Wait()
		}(i)
	}

	// ========== 第三步:等所有 worker 都准备好 ==========
	// 轮询检查,直到所有 worker 都就绪了
	for readyCount.Load() < int32(supervisorCount*workerCount) {
		time.Sleep(10 * time.Millisecond)
	}

	// ========== 第四步:全并发时采样峰值数据 ==========
	// 所有 goroutine 都已启动且在栅栏前等待,
	// 这时候的 goroutine 数和内存就是真正的峰值。

	var peakM runtime.MemStats
	runtime.ReadMemStats(&peakM)             // 读取当前内存统计
	peakGoroutines := runtime.NumGoroutine() // 读取当前 goroutine 总数

	// ========== 第五步:打开栅栏,所有 goroutine 同时开始 ==========
	startGate.Done() // 计数器减到 0,所有在 Wait() 的 goroutine 同时被唤醒

	// ========== 第六步:等所有任务都完成 ==========
	supervisorWg.Wait()

	// 计算总耗时
	elapsed := time.Since(startTime)
	totalWorkers := supervisorCount * workerCount

	// ========== 第七步:读取结束时的内存 ==========
	var endM runtime.MemStats
	runtime.ReadMemStats(&endM)

	// ========== 第八步:打印统计信息 ==========

	fmt.Println("===== 并发统计 =====")
	fmt.Printf("CPU 核心数: %d\n", runtime.NumCPU())
	fmt.Printf("总执行时间: %d ms\n", elapsed.Milliseconds())
	fmt.Printf("上级数量: %d\n", supervisorCount)
	fmt.Printf("总 worker 数量: %d\n", totalWorkers)

	fmt.Println("===== 峰值内存(全并发时) =====")
	fmt.Printf("Alloc(堆使用中): %.2f MB\n", float64(peakM.Alloc)/1024/1024)
	fmt.Printf("Sys(从 OS 获取的总内存): %.2f MB\n", float64(peakM.Sys)/1024/1024)
	fmt.Printf("Goroutine 数量: %d\n", peakGoroutines)

	fmt.Println("===== 结束内存(全部完成后) =====")
	fmt.Printf("Alloc(堆使用中): %.2f MB\n", float64(endM.Alloc)/1024/1024)
	fmt.Printf("TotalAlloc(累计分配): %.2f MB\n", float64(endM.TotalAlloc)/1024/1024)
	fmt.Printf("Sys(从 OS 获取的总内存): %.2f MB\n", float64(endM.Sys)/1024/1024)
	fmt.Printf("Goroutine 数量: %d\n", runtime.NumGoroutine())

	fmt.Println("==============================")
}

// go 结果
===== 并发统计 =====
CPU 核心数: 12
总执行时间: 1067 ms
上级数量: 100
总 worker 数量: 10000
===== 峰值内存(全并发时) =====
Alloc(堆使用中): 5.88 MB
Sys(从 OS 获取的总内存): 92.58 MB
Goroutine 数量: 10101
===== 结束内存(全部完成后) =====
Alloc(堆使用中): 6.86 MB
TotalAlloc(累计分配): 7.23 MB
Sys(从 OS 获取的总内存): 96.58 MB
Goroutine 数量: 1
==============================

JDK-21

// JDK-21 虚拟线程[初始代码来自AI]
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Java 虚拟线程版本 - 两级并发演示(JDK 21+)
 *
 * 架构:
 *   使用虚拟线程(用户态轻量级线程),而不是操作系统线程。
 *   上级任务和子任务都跑在同一个虚拟线程执行器上。
 *
 * 为什么用虚拟线程?
 *   - 极轻量(栈在堆上,初始只有几 KB)
 *   - 可以轻松跑 10 万+ 并发任务,内存开销极低
 *   - 阻塞操作(sleep、I/O)不会阻塞底层的 OS 线程
 *   - 性能和内存表现与 Go goroutine 类似
 *
 * 需要 JDK 21 或更高版本(虚拟线程在 JDK 21 成为正式稳定特性)。
 */
public class Main {

    // ========== 任务数量配置 ==========

    /** 上级任务数量(第一级) */
    private static final int OUTER_TASK_COUNT = 100;

    /** 每个上级任务下的子任务数量(第二级) */
    private static final int INNER_TASK_COUNT = 100;

    /** 模拟 I/O 时长(1 秒 = 1000 毫秒) */
    private static final long SLEEP_MILLIS = 1000L;

    /**
     * 主方法:程序入口
     *
     * 使用 try-with-resources 管理 ExecutorService(JDK 19+ 特性):
     *   - try 块退出时 executor 会自动关闭
     *   - 关闭前会等待所有已提交的任务完成
     *
     * @param args 命令行参数(没用到)
     * @throws InterruptedException 线程中断异常
     */
    public static void main(String[] args) throws InterruptedException {

        // 创建一个"每个任务一个虚拟线程"的执行器
        // 每个提交的任务都会得到自己的虚拟线程
        // 虚拟线程由 JVM 管理,而不是操作系统
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {

            // 记录开始时间
            long startTime = System.currentTimeMillis();

            // ========== 采样器设置 ==========
            // 用一个后台采样线程来记录峰值数据。
            // 虚拟线程没有 getPoolSize() 方法,
            // 所以我们用 AtomicInteger 手动统计活跃数量。

            // 峰值活跃虚拟线程数(观测到的最高并发数)
            AtomicInteger peakVirtualThreads = new AtomicInteger(0);
            // 并发最高时的峰值内存
            long[] peakMemory = {0};
            // 采样线程完全停止的信号门闩
            CountDownLatch samplerDone = new CountDownLatch(1);
            // 当前活跃虚拟任务计数器(开始时 +1,结束时 -1)
            AtomicInteger activeCount = new AtomicInteger(0);

            // 创建一个专门的采样线程(OS 线程,不是虚拟线程)
            Thread sampler = new Thread(() -> {
                try {
                    // 持续采样直到被中断
                    while (!Thread.currentThread().isInterrupted()) {
                        // 读取当前活跃虚拟线程数
                        int active = activeCount.get();
                        // 如果达到新高,更新峰值
                        if (active > peakVirtualThreads.get()) {
                            peakVirtualThreads.set(active);
                            Runtime rt = Runtime.getRuntime();
                            // 已使用内存 = 总内存 - 空闲内存
                            peakMemory[0] = rt.totalMemory() - rt.freeMemory();
                        }
                        // 两次采样间隔 10ms,避免太占 CPU
                        Thread.sleep(10);
                    }
                } catch (InterruptedException e) {
                    // 恢复中断标记(好习惯)
                    Thread.currentThread().interrupt();
                } finally {
                    // 通知采样完成(正常退出或被中断都算)
                    samplerDone.countDown();
                }
            }, "memory-sampler");

            // 设为守护线程:不会阻止 JVM 退出
            sampler.setDaemon(true);
            // 启动采样器
            sampler.start();

            // ========== 提交上级任务 ==========
            // 每个上级任务创建 INNER_TASK_COUNT 个工作任务并等待它们完成。

            // 装所有上级任务 Future 的列表
            List<CompletableFuture<Void>> outerFutures = new ArrayList<>();

            for (int i = 0; i < OUTER_TASK_COUNT; i++) {
                // 提交一个上级任务(跑在虚拟线程上)
                CompletableFuture<Void> outer = CompletableFuture.runAsync(() -> {

                    // --- 上级任务主体开始 ---

                    // 标记这个上级任务开始了
                    activeCount.incrementAndGet();
                    try {
                        // 装这个上级任务下所有工作任务 Future 的列表
                        List<CompletableFuture<Void>> innerFutures = new ArrayList<>();

                        // 提交所有工作任务
                        for (int j = 0; j < INNER_TASK_COUNT; j++) {
                            // 提交一个工作任务(也跑在虚拟线程上)
                            CompletableFuture<Void> inner = CompletableFuture.runAsync(() -> {
                                // 标记这个工作任务开始了
                                activeCount.incrementAndGet();
                                try {
                                    // 模拟 I/O 操作(数据库查询、HTTP 调用等)
                                    // 对于虚拟线程,sleep() 会从载体线程上卸载下来,
                                    // 这样底层的 OS 线程就可以去跑其他虚拟线程了。
                                    Thread.sleep(SLEEP_MILLIS);
                                } catch (InterruptedException e) {
                                    // 恢复中断标记
                                    Thread.currentThread().interrupt();
                                } finally {
                                    // 标记这个工作任务结束了
                                    activeCount.decrementAndGet();
                                }
                            }, executor);

                            innerFutures.add(inner);
                        }

                        // 等这个上级任务的所有工作任务都完成
                        allOf(innerFutures).join();

                    } finally {
                        // 标记这个上级任务结束了
                        activeCount.decrementAndGet();
                    }

                    // --- 上级任务主体结束 ---

                }, executor);

                outerFutures.add(outer);
            }

            // ========== 等待所有任务完成 ==========
            // 阻塞直到每个上级(以及每个工作任务)都完成
            allOf(outerFutures).join();

            // ========== 收集结果 ==========

            // 中断采样器让它停止
            sampler.interrupt();
            // 等采样器完全停止(确保峰值数据都写好了)
            samplerDone.await();

            // 计算总耗时
            long endTime = System.currentTimeMillis();
            long totalTime = endTime - startTime;

            // 读取结束时的内存
            Runtime rt = Runtime.getRuntime();
            long endUsed = rt.totalMemory() - rt.freeMemory();

            // 打印所有统计信息
            printStatistics(totalTime, peakMemory[0], peakVirtualThreads.get(), endUsed);
        }
    }

    /**
     * 工具方法:等列表里所有 Future 都完成
     *
     * 为什么要封装这个方法?
     *   CompletableFuture.allOf() 接受可变参数(底层是数组),
     *   但 Java 不允许创建泛型数组(会触发 unchecked 警告)。
     *   我们把警告封装在这里,业务代码保持干净。
     *
     * @param futures Future 列表
     * @return 一个组合的 Future,所有输入都完成后它才完成
     */
    @SuppressWarnings("unchecked")
    private static CompletableFuture<Void> allOf(List<CompletableFuture<Void>> futures) {
        // List 转数组(这一行就是触发 unchecked 警告的地方)
        CompletableFuture<Void>[] array = futures.toArray(new CompletableFuture[0]);
        // 委托给 JDK 内置的 allOf
        return CompletableFuture.allOf(array);
    }

    /**
     * 打印统计信息到控制台
     *
     * @param totalTimeMillis    总执行时间(毫秒)
     * @param peakUsedMemory     峰值堆内存(并发最高时),单位字节
     * @param peakVirtualThreads 峰值活跃虚拟线程数
     * @param endUsedMemory      所有任务完成后的堆内存,单位字节
     */
    private static void printStatistics(long totalTimeMillis,
                                         long peakUsedMemory,
                                         int peakVirtualThreads,
                                         long endUsedMemory) {
        Runtime runtime = Runtime.getRuntime();
        int cpuCores = Runtime.getRuntime().availableProcessors();
        // 总子任务数 = 上级数 × 每个上级的子任务数
        int totalSubTasks = OUTER_TASK_COUNT * INNER_TASK_COUNT;

        System.out.println("========== 并发统计 ==========");
        System.out.println("CPU 核心数: " + cpuCores);
        System.out.println("总执行时间: " + totalTimeMillis + " ms");
        System.out.println("上级任务数: " + OUTER_TASK_COUNT);
        System.out.println("总子任务数: " + totalSubTasks);
        System.out.println("线程模型: 虚拟线程(JDK 21+)");
        System.out.println("峰值活跃虚拟线程数: " + peakVirtualThreads);

        System.out.println("========== 内存使用 ==========");
        // 字节转 MB:除以 1024 两次
        System.out.println("峰值使用内存: " + (peakUsedMemory / 1024 / 1024) + " MB");
        System.out.println("结束使用内存: " + (endUsedMemory / 1024 / 1024) + " MB");
        System.out.println("总内存: " + (runtime.totalMemory() / 1024 / 1024) + " MB");
        System.out.println("最大内存: " + (runtime.maxMemory() / 1024 / 1024) + " MB");
        System.out.println("==============================");
    }
}

// jdk21 结果
========== Concurrency Statistics ==========
CPU cores: 12
Total execution time: 1592 ms
Supervisor task count: 100
Total sub-task count: 10000
Thread model: Virtual Threads (JDK 21+)
Peak active virtual threads: 10100
========== Memory Usage ==========
Peak used memory: 27 MB
End used memory: 28 MB
Total memory: 246 MB
Max memory: 3932 MB
============================================

JKD-1.8

// jdk1.8 [初始代码来自AI]
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Java 线程池版本 - 两级并发演示
 *
 * 架构:
 *   supervisorPool(上级线程池)→ 每个上级任务提交 100 个子任务到 workerPool
 *   workerPool(工作线程池)    → 真正执行 I/O 任务(sleep 模拟)
 *
 * 为什么用双线程池?
 *   避免"线程饥饿死锁":如果内外层共用一个线程池,外层任务占着线程等内层,
 *   内层任务没线程可跑,就会死锁。双线程池隔离后就不会有这个问题。
 */
public class Main {

    // ========== 任务数量配置 ==========

    /** 上级任务数量(第一级) */
    private static final int OUTER_TASK_COUNT = 100;

    /** 每个上级任务下的子任务数量(第二级) */
    private static final int INNER_TASK_COUNT = 100;

    /** CPU 核心数(逻辑核心,包括超线程) */
    private static final int CPU_CORES = Runtime.getRuntime().availableProcessors();

    // ========== supervisorPool 配置 ==========
    // supervisorPool 负责跑"上级任务"
    // 上级任务本身不做重活,就是提交 100 个子任务然后等它们完成
    // 所以不需要太多线程,CPU * 2 足够了

    /** 上级线程池 - 核心线程数(常驻线程) */
    private static final int SUPERVISOR_CORE_POOL_SIZE = CPU_CORES;

    /** 上级线程池 - 最大线程数(高峰时最多开多少) */
    private static final int SUPERVISOR_MAX_POOL_SIZE = CPU_CORES * 2;

    /** 上级线程池 - 任务队列容量(装不下的任务排队等) */
    private static final int SUPERVISOR_QUEUE_CAPACITY = OUTER_TASK_COUNT * 2;

    // ========== workerPool 配置 ==========
    // workerPool 负责跑"子任务"(真正的 I/O 操作)
    // I/O 密集型任务,线程大部分时间在 sleep,所以可以开多一点
    // 公式:线程数 = CPU核心数 * (1 + 等待时间/计算时间)

    /** 工作线程池 - 核心线程数(常驻线程) */
    private static final int WORKER_CORE_POOL_SIZE = CPU_CORES * 10;

    /** 工作线程池 - 最大线程数(高峰时的上限) */
    private static final int WORKER_MAX_POOL_SIZE = CPU_CORES * 20;

    /** 工作线程池 - 任务队列容量(等于总任务数,保证不会拒绝任务) */
    private static final int WORKER_QUEUE_CAPACITY = OUTER_TASK_COUNT * INNER_TASK_COUNT;

    // ========== 其他参数 ==========

    /** 线程空闲多久后回收(核心线程之外的) */
    private static final long KEEP_ALIVE_SECONDS = 60L;

    /** 子任务 sleep 时间,模拟 1 秒的数据库 I/O */
    private static final long SLEEP_MILLIS = 1000L;

    /**
     * 主方法:程序入口
     * @param args 命令行参数(没用到)
     * @throws InterruptedException 线程中断异常
     */
    public static void main(String[] args) throws InterruptedException {

        // ========== 第一步:创建两个线程池 ==========
        // supervisorPool:跑上级任务(协调者)
        // workerPool:跑子任务(真正干活的)
        ThreadPoolExecutor supervisorPool = createSupervisorPool();
        ThreadPoolExecutor workerPool = createWorkerPool();

        try {
            // 记录开始时间
            long startTime = System.currentTimeMillis();

            // ========== 第二步:启动内存/线程采样线程 ==========
            // 用一个单独的线程后台轮询,记录运行过程中的峰值数据

            // 峰值线程数(原子类,多线程安全)
            AtomicInteger peakThreads = new AtomicInteger(0);
            // 峰值内存(用数组是为了在 lambda 里能修改)
            long[] peakMemory = {0};
            // 采样线程结束的倒计时门闩(用来等采样线程真正结束)
            CountDownLatch samplerDone = new CountDownLatch(1);

            // 创建采样线程,名字叫 "memory-sampler"
            Thread sampler = new Thread(() -> {
                try {
                    // 循环采样,直到被中断
                    while (!Thread.currentThread().isInterrupted()) {
                        // 当前总线程数(包括空闲的)
                        int total = supervisorPool.getPoolSize() + workerPool.getPoolSize();

                        // 只在线程数创新高时记录内存
                        // 注意:这样记录的是"线程数最多那一刻"的内存,不一定是内存最高峰
                        if (total > peakThreads.get()) {
                            peakThreads.set(total);
                            Runtime rt = Runtime.getRuntime();
                            // 已使用内存 = 总内存 - 空闲内存
                            peakMemory[0] = rt.totalMemory() - rt.freeMemory();
                        }

                        // 睡 10 毫秒再采一次,别太频繁占 CPU
                        Thread.sleep(10);
                    }
                } catch (InterruptedException e) {
                    // 被中断了,重新设置中断标记(好习惯)
                    Thread.currentThread().interrupt();
                } finally {
                    // 不管正常结束还是被中断,都把计数器减一
                    // 这样主线程的 await() 就能返回了
                    samplerDone.countDown();
                }
            }, "memory-sampler");

            // 设为守护线程:主线程结束时它会自动跟着结束,不会卡住 JVM 退出
            sampler.setDaemon(true);
            // 启动采样线程
            sampler.start();

            // ========== 第三步:提交所有上级任务 ==========
            // 外层 List:装所有上级任务的 Future
            List<CompletableFuture<?>> outerFutures = new ArrayList<>();

            // 循环提交 100 个上级任务
            for (int i = 0; i < OUTER_TASK_COUNT; i++) {
                // 用 runAsync 提交一个无返回值的任务到 supervisorPool
                CompletableFuture<?> outer = CompletableFuture.runAsync(() -> {

                    // ====== 下面是"上级任务"的代码 ======
                    // 每个上级任务负责:提交 100 个子任务,等它们都完成

                    // 内层 List:装这个上级任务下所有子任务的 Future
                    List<CompletableFuture<?>> innerFutures = new ArrayList<>();

                    // 循环提交 100 个子任务到 workerPool
                    for (int j = 0; j < INNER_TASK_COUNT; j++) {
                        // 子任务:sleep 1 秒,模拟数据库 I/O
                        CompletableFuture<?> inner = CompletableFuture.runAsync(() -> {
                            try {
                                // 模拟 1 秒的数据库查询 I/O
                                Thread.sleep(SLEEP_MILLIS);
                            } catch (InterruptedException e) {
                                // 被中断的话,重新设置中断标记
                                Thread.currentThread().interrupt();
                            }
                        }, workerPool);

                        // 把子任务的 Future 加到列表里
                        innerFutures.add(inner);
                    }

                    // 等所有子任务都完成(allOf 返回一个组合 Future,join() 阻塞等待)
                    allOf(innerFutures).join();
                    // ====== 上级任务代码结束 ======

                }, supervisorPool);

                // 把上级任务的 Future 加到外层列表
                outerFutures.add(outer);
            }

            // ========== 第四步:等所有上级任务都完成 ==========
            allOf(outerFutures).join();

            // ========== 第五步:停止采样,收集结果 ==========

            // 中断采样线程,让它退出循环
            sampler.interrupt();
            // 等采样线程真正结束(确保最后一次采样数据都写好了)
            samplerDone.await();

            // 记录结束时间
            long endTime = System.currentTimeMillis();
            long totalTime = endTime - startTime;

            // 读取结束时的内存
            Runtime rt = Runtime.getRuntime();
            long endUsed = rt.totalMemory() - rt.freeMemory();

            // 打印统计信息
            printStatistics(totalTime, supervisorPool, workerPool,
                    peakMemory[0], peakThreads.get(), endUsed);

        } finally {
            // ========== 第六步:关闭线程池(重要!) ==========
            // 用 try-finally 保证即使出异常也能关闭,防止线程泄漏
            shutdownPool(supervisorPool);
            shutdownPool(workerPool);
        }
    }

    /**
     * 工具方法:等列表里所有 Future 都完成
     *
     * @param futures Future 列表
     * @return 一个组合的 Future,所有输入都完成后它才完成
     */
    private static CompletableFuture<?> allOf(List<CompletableFuture<?>> futures) {
        // List 转数组(toArray 返回的是泛型数组,所以有 unchecked 警告)
        CompletableFuture<?>[] array = futures.toArray(new CompletableFuture[0]);
        // 调用 JDK 自带的 allOf,等所有 Future 都完成
        return CompletableFuture.allOf(array);
    }

    /**
     * 创建上级线程池(supervisorPool)
     * 负责执行"上级任务"——提交子任务 + 等待子任务完成
     */
    private static ThreadPoolExecutor createSupervisorPool() {
        // 自定义线程工厂:给线程起名字,排查问题时方便辨认
        ThreadFactory threadFactory = new ThreadFactory() {
            // 原子计数器,给线程编号用(线程安全)
            private final AtomicInteger threadNumber = new AtomicInteger(1);

            @Override
            public Thread newThread(Runnable r) {
                // 创建线程,名字叫 "supervisor-1"、"supervisor-2"...
                return new Thread(r, "supervisor-" + threadNumber.getAndIncrement());
            }
        };

        // 创建线程池,7 个参数一一对应:
        return new ThreadPoolExecutor(
                SUPERVISOR_CORE_POOL_SIZE,      // 1. 核心线程数(常驻,不会回收)
                SUPERVISOR_MAX_POOL_SIZE,       // 2. 最大线程数(高峰时最多开多少)
                KEEP_ALIVE_SECONDS,             // 3. 空闲线程存活时间
                TimeUnit.SECONDS,               // 4. 存活时间的单位
                new LinkedBlockingQueue<>(SUPERVISOR_QUEUE_CAPACITY),  // 5. 任务队列(有界阻塞队列)
                threadFactory,                  // 6. 线程工厂(创建线程用的)
                new ThreadPoolExecutor.CallerRunsPolicy()  // 7. 拒绝策略(队列满了怎么办)
        );
        // 拒绝策略 CallerRunsPolicy:
        //   队列满了、线程也开到上限了,再提交任务就让"提交任务的线程"自己去跑
        //   好处:不会丢任务,还能自然起到"限流"作用——提交者自己跑,就没空继续提交了
    }

    /**
     * 创建工作线程池(workerPool)
     * 负责执行"子任务"——sleep 模拟 I/O
     */
    private static ThreadPoolExecutor createWorkerPool() {
        // 自定义线程工厂:给工作线程起名字
        ThreadFactory threadFactory = new ThreadFactory() {
            private final AtomicInteger threadNumber = new AtomicInteger(1);

            @Override
            public Thread newThread(Runnable r) {
                // 名字格式:"worker-1"、"worker-2"...
                return new Thread(r, "worker-" + threadNumber.getAndIncrement());
            }
        };

        return new ThreadPoolExecutor(
                WORKER_CORE_POOL_SIZE,          // 核心线程数
                WORKER_MAX_POOL_SIZE,           // 最大线程数
                KEEP_ALIVE_SECONDS,             // 空闲存活时间
                TimeUnit.SECONDS,               // 时间单位
                new LinkedBlockingQueue<>(WORKER_QUEUE_CAPACITY),  // 任务队列
                threadFactory,                  // 线程工厂
                new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
        );
    }

    /**
     * 优雅关闭线程池
     *
     * 关闭流程:
     *   1. 调用 shutdown() — 停止接收新任务,已提交的继续跑完
     *   2. 等 60 秒 — 给正在跑的任务时间完成
     *   3. 如果超时还没跑完 — 调用 shutdownNow() 强制中断所有线程
     *   4. 如果等待过程中被中断 — 也强制关闭,并恢复中断标记
     */
    private static void shutdownPool(ThreadPoolExecutor pool) {
        // 第一步:温和关闭,不接新任务,已提交的继续跑
        pool.shutdown();
        try {
            // 等 60 秒,看能不能正常跑完
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                // 超时了还没跑完,强制关闭,中断所有线程
                pool.shutdownNow();
            }
        } catch (InterruptedException e) {
            // 等待过程中被人中断了,也强制关闭
            pool.shutdownNow();
            // 重新设置中断标记,让调用者知道发生了中断
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 打印统计信息
     *
     * @param totalTimeMillis  总耗时(毫秒)
     * @param supervisorPool   上级线程池(用来读配置)
     * @param workerPool       工作线程池(用来读配置)
     * @param peakUsedMemory   峰值内存(字节)
     * @param peakThreadCount  峰值线程数
     * @param endUsedMemory    结束时内存(字节)
     */
    private static void printStatistics(long totalTimeMillis,
                                         ThreadPoolExecutor supervisorPool,
                                         ThreadPoolExecutor workerPool,
                                         long peakUsedMemory,
                                         int peakThreadCount,
                                         long endUsedMemory) {
        Runtime runtime = Runtime.getRuntime();
        // 总子任务数 = 上级数 × 每个上级的子任务数
        int totalSubTasks = OUTER_TASK_COUNT * INNER_TASK_COUNT;

        System.out.println("========== Concurrency Statistics ==========");
        System.out.println("CPU cores: " + CPU_CORES);
        System.out.println("Total execution time: " + totalTimeMillis + " ms");
        System.out.println("Supervisor task count: " + OUTER_TASK_COUNT);
        System.out.println("Total sub-task count: " + totalSubTasks);

        System.out.println("========== Thread Pools ==========");
        System.out.println("Supervisor: core=" + SUPERVISOR_CORE_POOL_SIZE + ", max=" + SUPERVISOR_MAX_POOL_SIZE);
        System.out.println("Worker: core=" + WORKER_CORE_POOL_SIZE + ", max=" + WORKER_MAX_POOL_SIZE);
        System.out.println("Peak OS threads: " + peakThreadCount);

        System.out.println("========== Memory Usage ==========");
        // 字节转 MB:除以 1024 再除以 1024
        System.out.println("Peak used memory: " + (peakUsedMemory / 1024 / 1024) + " MB");
        System.out.println("End used memory: " + (endUsedMemory / 1024 / 1024) + " MB");
        System.out.println("Total memory: " + (runtime.totalMemory() / 1024 / 1024) + " MB");
        System.out.println("Max memory: " + (runtime.maxMemory() / 1024 / 1024) + " MB");
        System.out.println("==========================================");
    }
}


/** 结果 */
// JDK8 子线程数240 用时85秒 最大内存使用很小不到200M
========== Concurrency Statistics ==========
CPU cores: 12
Total execution time: 84838 ms
Supervisor task count: 100
Total sub-task count: 10000
========== Thread Pools ==========
Supervisor: core=12, max=24
Worker: core=120, max=240
Peak OS threads: 132
========== Memory Usage ==========
Peak used memory: 19 MB
End used memory: 48 MB
Total memory: 236 MB
Max memory: 3495 MB
==========================================

// JDK8 子线程数1000 用时20秒 最大内存使用530M
========== Concurrency Statistics ==========
CPU cores: 12
Total execution time: 20250 ms
Supervisor task count: 100
Total sub-task count: 10000
========== Thread Pools ==========
Supervisor: core=50, max=100
Worker: core=500, max=1000
Peak OS threads: 550
========== Memory Usage ==========
Peak used memory: 13 MB
End used memory: 50 MB
Total memory: 530 MB
Max memory: 3495 MB
==========================================

// jdk8 子线程数2000 用时10秒 最大内存使用1.4G
========== Concurrency Statistics ==========
CPU cores: 12
Total execution time: 10200 ms
Supervisor task count: 100
Total sub-task count: 10000
========== Thread Pools ==========
Supervisor: core=50, max=100
Worker: core=1000, max=2000
Peak OS threads: 1050
========== Memory Usage ==========
Peak used memory: 13 MB
End used memory: 980 MB
Total memory: 1471 MB
Max memory: 3495 MB
==========================================

// jkd8 子线程数3000 用时7秒 最大内存使用1.4G
========== Concurrency Statistics ==========
CPU cores: 12
Total execution time: 7175 ms
Supervisor task count: 100
Total sub-task count: 10000
========== Thread Pools ==========
Supervisor: core=50, max=100
Worker: core=1500, max=3000
Peak OS threads: 1550
========== Memory Usage ==========
Peak used memory: 32 MB
End used memory: 398 MB
Total memory: 1470 MB
Max memory: 3495 MB
==========================================

\\ jdk8 子线程数4000 用时5秒 最大内存使用1.4G
========== Concurrency Statistics ==========
CPU cores: 12
Total execution time: 5232 ms
Supervisor task count: 100
Total sub-task count: 10000
========== Thread Pools ==========
Supervisor: core=50, max=100
Worker: core=2000, max=4000
Peak OS threads: 2050
========== Memory Usage ==========
Peak used memory: 35 MB
End used memory: 1250 MB
Total memory: 1470 MB
Max memory: 3495 MB
==========================================

// jdk8 子线程数5000 用时和4000相同,已是最快
========== Concurrency Statistics ==========
CPU cores: 12
Total execution time: 5218 ms
Supervisor task count: 100
Total sub-task count: 10000
========== Thread Pools ==========
Supervisor: core=50, max=100
Worker: core=2000, max=5000
Peak OS threads: 2050
========== Memory Usage ==========
Peak used memory: 32 MB
End used memory: 141 MB
Total memory: 1472 MB
Max memory: 3495 MB
==========================================

Logo

汇聚全球AI编程工具,助力开发者即刻编程。

更多推荐