文章目录
-
- 一、概述
- 二、虚拟线程的基本概念与原理
-
- 2.1 平台线程与虚拟线程的核心区别
- 2.2 虚拟线程的工作机制
- 三、虚拟线程的实际使用示例
-
- 3.1 创建和运行虚拟线程的基本方式
-
- 方式一：使用Thread类创建
- 方式二：使用Thread.Builder接口
- 方式三：使用Executors创建
- 3.2 完整的客户端-服务器示例
- 3.3 并行任务处理示例
- 四、虚拟线程的最佳实践
-
- 4.1 采用同步阻塞式I/O编程模型
- 4.2 为每个并发任务创建独立的虚拟线程
- 4.3 使用信号量控制并发度
- 4.4 避免在线程本地变量中缓存昂贵对象
- 4.5 避免频繁和长时间的锁定（Pinning）
- 五、性能对比与适用场景
-
- 5.1 虚拟线程的性能特点
- 5.2 适用场景与不适用场景
- 5.3 性能监控与调优
- 六、调试与故障排查
-
- 6.1 虚拟线程的调试特性
- 6.2 线程转储分析
- 七、总结与建议
-
- 7.1 核心要点回顾
- 7.2 迁移建议
- 八、官方参考资源
一、概述
Java虚拟线程（Virtual Threads）是Java 21引入的重要特性，作为Project Loom的核心成果，它从根本上改变了Java的并发编程模型。虚拟线程是一种轻量级线程，能够显著减少编写、维护和调试高并发应用程序的工作量。
关键特性：
- 轻量级特性：虚拟线程相比平台线程具有更小的资源占用，单个JVM可以支持数百万个虚拟线程同时运行
- 调度方式：由Java运行时调度而非操作系统调度，映射到少量操作系统线程上实现高效并发
- 适用场景：特别适合I/O密集型任务，能够大幅提升高并发应用的吞吐量
- 编程模型：采用传统的阻塞式I/O编程风格，简化了并发程序的开发和调试
二、虚拟线程的基本概念与原理
2.1 平台线程与虚拟线程的核心区别
平台线程（Platform Threads）：
- 平台线程是操作系统线程的薄包装层，直接映射到OS线程
- 每个平台线程在整个生命周期内绑定一个操作系统线程
- 受限于操作系统线程的数量，通常具有较大的线程栈和其他资源开销
虚拟线程（Virtual Threads）：
- 虚拟线程也是java.lang.Thread的实例，但并不绑定特定的操作系统线程
- 代码运行在操作系统线程上，但当调用阻塞I/O操作时，Java运行时会挂起虚拟线程直到可以恢复
- 采用类似虚拟内存的实现方式：将大量虚拟线程映射到少量操作系统线程上
2.2 虚拟线程的工作机制
挂载与卸载机制：
虚拟线程 → 挂载到平台线程 → 运行代码 → 可能阻塞I/O → 卸载 → 平台线程被释放调度其他虚拟线程
这种设计使得少量平台线程能够高效服务大量虚拟线程，特别适合I/O密集型应用场景。
三、虚拟线程的实际使用示例
3.1 创建和运行虚拟线程的基本方式
方式一：使用Thread类创建
// 创建并启动一个虚拟线程
Thread thread = Thread.ofVirtual().start(() -> System.out.println("Hello"));
thread.join(); // 等待虚拟线程终止
方式二：使用Thread.Builder接口
// 创建带有自定义名称的虚拟线程
Thread.Builder builder = Thread.ofVirtual().name("MyThread");
Runnable task = () -> System.out.println("Running thread");
Thread t = builder.start(task);
System.out.println("Thread t name: " + t.getName());
t.join();
方式三：使用Executors创建
// 使用ExecutorService管理虚拟线程
try (ExecutorService myExecutor = Executors.newVirtualThreadPerTaskExecutor()) {
Future future = myExecutor.submit(() -> System.out.println("Running thread"));
future.get(); // 等待任务完成
System.out.println("Task completed");
}
3.2 完整的客户端-服务器示例
以下示例展示了如何使用虚拟线程构建高并发的服务器应用：
服务器端代码（EchoServer.java）：
public class EchoServer {
public static void main(String[] args) throws IOException {
if (args.length != 1) {
System.err.println("Usage: java EchoServer <port>");
System.exit(1);
}
int portNumber = Integer.parseInt(args[0]);
try (ServerSocket serverSocket = new ServerSocket(portNumber)) {
while (true) {
Socket clientSocket = serverSocket.accept();
// 为每个客户端连接启动一个虚拟线程
Thread.ofVirtual().start(() -> {
try (PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Received: " + inputLine);
out.println(inputLine); // 回显给客户端
}
} catch (IOException e) {
e.printStackTrace();
}
});
}
} catch (IOException e) {
System.out.println("Exception caught when trying to listen on port " + portNumber);
System.out.println(e.getMessage());
}
}
}
客户端代码（EchoClient.java）：
public class EchoClient {
public static void main(String[] args) throws IOException {
if (args.length != 2) {
System.err.println("Usage: java EchoClient <host> <port>");
System.exit(1);
}
String hostName = args[0];
int portNumber = Integer.parseInt(args[1]);
try (Socket echoSocket = new Socket(hostName, portNumber);
PrintWriter out = new PrintWriter(echoSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(echoSocket.getInputStream()))) {
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("echo: " + in.readLine());
if (userInput.equals("bye")) {
break;
}
}
} catch (UnknownHostException e) {
System.err.println("Don't know about host " + hostName);
System.exit(1);
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to " + hostName);
System.exit(1);
}
}
}
3.3 并行任务处理示例
虚拟线程特别适合需要大量并行处理的场景：
void handle(Request request, Response response) {
var url1 = ...;
var url2 = ...;
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
var future1 = executor.submit(() -> fetchURL(url1));
var future2 = executor.submit(() -> fetchURL(url2));
response.send(future1.get() + future2.get());
} catch (ExecutionException | InterruptedException e) {
response.fail(e);
}
}
String fetchURL(URL url) throws IOException {
try (var in = url.openStream()) {
return new String(in.readAllBytes(), StandardCharsets.UTF_8);
}
}
四、虚拟线程的最佳实践
4.1 采用同步阻塞式I/O编程模型
核心原则：使用简单的同步代码和阻塞I/O API，而不是复杂的异步编程模型。
示例对比：
不推荐的异步代码（无法充分利用虚拟线程优势）：
CompletableFuture.supplyAsync(info::getUrl, pool)
.thenCompose(url -> getBodyAsync(url, HttpResponse.BodyHandlers.ofString()))
.thenApply(info::findImage)
.thenCompose(url -> getBodyAsync(url, HttpResponse.BodyHandlers.ofByteArray()))
.thenApply(info::setImageData)
.thenAccept(this::process)
.exceptionally(t -> {
t.printStackTrace();
return null;
});
推荐的同步代码（能够充分利用虚拟线程优势）：
try {
String page = getBody(info.getUrl(), HttpResponse.BodyHandlers.ofString());
String imageUrl = info.findImage(page);
byte[] data = getBody(imageUrl, HttpResponse.BodyHandlers.ofByteArray());
info.setImageData(data);
process(info);
} catch (Exception ex) {
ex.printStackTrace();
}
4.2 为每个并发任务创建独立的虚拟线程
关键原则：虚拟线程应该代表应用程序的任务，而不是作为共享资源进行池化管理。
错误示例（使用共享线程池）：
Future f1 = sharedThreadPoolExecutor.submit(task1);
Future f2 = sharedThreadPoolExecutor.submit(task2);
// … 使用futures
正确示例（使用虚拟线程执行器）：
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
Future f1 = executor.submit(task1);
Future f2 = executor.submit(task2);
// … 使用futures
}
经验法则：如果应用程序中的虚拟线程数量从未达到10,000个或更多，那么可能无法从虚拟线程中受益。
4.3 使用信号量控制并发度
当需要限制特定操作的并发度时，应使用Semaphore而不是线程池：
Semaphore sem = new Semaphore(10); // 最多10个并发访问
Result foo() {
sem.acquire();
try {
return callLimitedService();
} finally {
sem.release();
}
}
4.4 避免在线程本地变量中缓存昂贵对象
虚拟线程不应该在线程本地变量中缓存可重用的昂贵对象，因为每个任务都有自己的虚拟线程，这会导致对象实例化过多。
错误示例（在虚拟线程环境中使用ThreadLocal缓存）：
static final ThreadLocal<SimpleDateFormat> cachedFormatter =
ThreadLocal.withInitial(SimpleDateFormat::new);
void foo() {
... cachedFormatter.get().format(...);
...
}
正确示例（使用不可变对象）：
static final DateTimeFormatter formatter =
DateTimeFormatter.ofPattern("yyyy-MM-dd");
void foo() {
... formatter.format(...);
...
}
4.5 避免频繁和长时间的锁定（Pinning）
问题说明：在同步块或方法中执行阻塞操作会导致虚拟线程"锁定"（pin）其承载的平台线程，影响吞吐量。
检测方法：
- 使用JDK Flight Recorder监控jdk.VirtualThreadPinned事件（默认启用，阈值为20ms）
- 使用系统属性-Djdk.tracePinnedThreads打印锁定线程的堆栈跟踪
优化建议：
- 用ReentrantLock替换频繁执行长时间I/O操作的synchronized块
- 短时间或频率低的同步操作可以保持使用synchronized
五、性能对比与适用场景
5.1 虚拟线程的性能特点
重要说明：虚拟线程并不是为了降低延迟，而是为了提高吞吐量。
性能优势：
- 高吞吐量：能够在相同的硬件资源下处理更多的并发请求
- 资源利用率高：少量平台线程能够高效服务大量虚拟线程
- 简化编程模型：使用传统的阻塞式I/O，降低开发和调试复杂度
性能局限：
- 虚拟线程并不比平台线程更快地执行代码
- 对于CPU密集型任务，虚拟线程无法提供性能提升
5.2 适用场景与不适用场景
✅ 适用场景：
- 高并发服务器应用（如Web服务器、API网关）
- I/O密集型任务（数据库访问、文件操作、网络通信）
- 请求-响应架构的分布式系统
- 需要大量并发连接的长连接服务
❌ 不适用场景：
- CPU密集型计算任务（如科学计算、图像处理）
- 需要严格实时性的系统
- 已经使用异步编程模型且性能良好的应用
- 并发度很低的应用
5.3 性能监控与调优
监控工具：
- JDK Flight Recorder：监控虚拟线程的生命周期、锁定事件等
- jcmd工具：生成包含虚拟线程信息的转储文件jcmd Thread.dump_to_file -format=json
性能调优关键点：
- 监控虚拟线程的挂起和恢复频率
- 识别并优化长时间锁定操作
- 合理设置信号量限制，避免不必要的等待
- 使用结构化并发模式提高可观测性
六、调试与故障排查
6.1 虚拟线程的调试特性
虚拟线程可以像平台线程一样进行调试，但也有一些特殊考虑：
JDK Flight Recorder事件：
- jdk.VirtualThreadStart和jdk.VirtualThreadEnd：虚拟线程的启动和结束（默认禁用）
- jdk.VirtualThreadPinned：虚拟线程被锁定时间过长（默认启用，20ms阈值）
- jdk.VirtualThreadSubmitFailed：虚拟线程启动或恢复失败
6.2 线程转储分析
生成包含虚拟线程信息的转储文件：
jcmd Thread.dump_to_file -format=json
注意：虚拟线程转储不包含对象地址、锁信息、JNI统计、堆统计等传统线程转储信息。
七、总结与建议
7.1 核心要点回顾
7.2 迁移建议
对于现有应用：
- 评估应用的并发特征和性能瓶颈
- 逐步将I/O密集型代码路径迁移为虚拟线程实现
- 保持监控和性能测试，确保改进效果
- 注意与异步框架的兼容性问题
对于新项目：
- 优先考虑虚拟线程作为默认并发模型
- 采用结构化并发模式提高代码可维护性
- 建立完善的监控体系，及时发现性能问题
- 团队培训和代码审查确保最佳实践落地
八、官方参考资源
- Oracle官方文档：Virtual Threads
- JEP规范：JEP 444: Virtual Threads
