多线程任务处理 JDK8, JDK21, GO 对比
·
任务场景:分别实现"两级并发"模型:100 个上级执行单元,每个上级单元再启动 100 个子执行单元,子单元模拟 1 秒的数据库 I/O 等待。用于对比Java和Go在高并发场景下的实现方式与执行效率。
代码环境:Go 1.22.0、JDK-1.8、JDK-21, 电脑硬件:CPU R5-5600、内存16G、Win11
测试结果:
- Go goroutine 最快最省内存 :耗时最短(1067ms),堆内存最少(5.88MB)
- Java 虚拟线程接近 Go :1592ms、27MB,和 Go 差距不大
- 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
==========================================
更多推荐


所有评论(0)