详细介绍 Java 21 引入的虚拟线程技术。内容包括前提准备、基础用法（直接启动、手动创建、Future 获取结果）、进阶用法（虚拟线程池、定时任务变通方案）以及 Spring Boot 实战集成。重点强调虚拟线程适用于高并发 I/O 场景，需注意避免 CPU 密集型任务、ThreadLocal 内存泄漏及锁竞争问题，并提供相关代码示例与最佳实践建议。
虚拟线程是 Java 21 正式引入的轻量级用户态线程，核心优势是低开销、高并发、支持同步编程模型实现异步性能。下面将从前提准备、基础用法、进阶用法、实战场景、注意事项五个方面详细讲解具体使用方式。
--enable-preview 启用，不推荐生产环境使用）。编译运行说明：若使用 Java 19/20（预览版），编译和运行时需添加 --enable-preview 参数：
# 编译
javac --enable-preview -source 20 VirtualThreadDemo.java
# 运行
java --enable-preview VirtualThreadDemo
环境验证：通过以下命令验证 Java 版本，确保满足要求：
java -version
# 预期输出（示例）：openjdk version "21.0.1" 2023-10-17 LTS
虚拟线程的创建和启动方式简洁，支持多种写法，核心 API 位于 java.lang.Thread 类中。
使用 Thread.startVirtualThread(Runnable) 直接创建并启动虚拟线程，无需手动调用 start() 方法，是最简单的使用方式。
public class VirtualThreadBasicDemo1 {
public static void main(String[] args) throws InterruptedException {
// 1. 启动单个虚拟线程
Thread.startVirtualThread(() -> {
// 虚拟线程执行的业务逻辑（支持同步阻塞操作）
System.out.printf("虚拟线程 1 执行中，线程 ID：%s，是否为虚拟线程：%b%n",
Thread.currentThread().threadId(), Thread.currentThread().isVirtual());
try {
// 模拟 I/O 阻塞（虚拟线程阻塞时会释放载体线程，不占用内核资源）
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("虚拟线程 1 执行完成");
});
// 2. 批量启动多个虚拟线程（支持百万级并发，资源消耗极低）
for (int i = 2; i <= 10; i++) {
int threadNum = i;
Thread.startVirtualThread(() -> {
System.out.printf("虚拟线程%d执行中，线程 ID：%s%n", threadNum, Thread.currentThread().threadId());
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.printf("虚拟线程%d执行完成%n", threadNum);
});
}
// 主线程等待所有虚拟线程执行完成（实际开发中无需手动等待，虚拟线程由 JVM 管理）
Thread.sleep(2000);
System.out.println("所有虚拟线程执行完毕，主线程退出");
}
}
通过 Thread.ofVirtual() 创建 Thread.Builder，可配置虚拟线程名称、优先级等属性，再通过 start() 启动，适合需要自定义线程属性的场景。
public class VirtualThreadBasicDemo2 {
public static void main(String[] args) throws InterruptedException {
// 1. 创建虚拟线程构建器，配置线程名称
Thread virtualThread = Thread.ofVirtual()
.name("business-virtual-thread-1") // 设置线程名称，便于调试
.unstarted(() -> { // 定义任务逻辑，暂不启动
System.out.printf("自定义虚拟线程执行中，线程名称：%s，是否为虚拟线程：%b%n",
Thread.currentThread().getName(), Thread.currentThread().isVirtual());
try {
// 模拟数据库查询阻塞
Thread.sleep(800);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("自定义虚拟线程执行完成");
});
// 2. 手动启动虚拟线程
virtualThread.start();
// 3. 链式创建并启动（简化写法）
Thread.ofVirtual()
.name("business-virtual-thread-2")
.start(() -> {
System.out.printf("链式创建虚拟线程执行中，线程名称：%s%n", Thread.currentThread().getName());
try {
Thread.sleep(600);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("链式创建虚拟线程执行完成");
});
// 主线程等待
Thread.sleep(1500);
System.out.println("主线程退出");
}
}
若虚拟线程执行的任务需要返回结果，可使用 ExecutorService 配合 Callable，通过 Future 获取返回值，这是实际开发中处理有结果任务的常用方式。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class VirtualThreadFutureDemo {
public static void main(String[] args) throws InterruptedException, ExecutionException {
// 创建虚拟线程池（每个任务对应一个虚拟线程）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
// 1. 提交有返回值的任务（Callable）
Future<String> future1 = executor.submit(new Callable<String>() {
@Override
public String call() throws Exception {
System.out.printf("任务 1 执行中，虚拟线程名称：%s%n", Thread.currentThread().getName());
Thread.sleep(1000); // 模拟 I/O 阻塞
return "任务 1 执行结果：成功";
}
});
// 2. 提交 Lambda 表达式形式的 Callable 任务（简化写法）
Future<Integer> future2 = executor.submit(() -> {
System.out.printf("任务 2 执行中，虚拟线程名称：%s%n", Thread.currentThread().getName());
Thread.sleep(800);
return 100 + 200; // 业务计算逻辑
});
// 3. 获取任务返回结果（阻塞获取，若需非阻塞可使用 isDone() 判断）
String result1 = future1.get();
Integer result2 = future2.get();
System.out.println("任务 1 返回结果：" + result1);
System.out.println("任务 2 返回结果：" + result2);
}
// try-with-resources 会自动关闭 executor，无需手动 shutdown()
System.out.println("所有任务执行完毕，主线程退出");
}
}
实际开发中，不推荐手动创建大量虚拟线程，而是使用虚拟线程池管理任务，Java 提供了专门的虚拟线程池实现，核心是 Executors.newVirtualThreadPerTaskExecutor()。
AutoCloseable 接口，可通过 try-with-resources 自动关闭，避免资源泄漏。ScheduledExecutorService，Java 21 暂未提供原生虚拟线程定时线程池，可通过第三方库或自定义实现）。import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
public class VirtualThreadPoolBatchDemo {
public static void main(String[] args) {
// 创建虚拟线程池
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
// 批量提交 1000 个任务（支持百万级任务，内存占用仅几十 MB）
List<Runnable> tasks = IntStream.range(0, 1000)
.mapToObj(i -> (Runnable) () -> {
System.out.printf("批量任务%d执行中，虚拟线程 ID：%s%n", i, Thread.currentThread().threadId());
try {
// 模拟每个任务的 I/O 阻塞（如数据库查询、HTTP 调用）
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
System.out.printf("批量任务%d执行完成%n", i);
})
.toList();
// 提交所有任务
tasks.forEach(executor::submit);
// 等待所有任务执行完成（可选，executor 关闭时会等待任务执行完毕）
System.out.println("所有批量任务已提交，等待执行完成...");
}
// 自动关闭线程池，等待所有任务执行完毕
System.out.println("批量任务全部处理完成，主线程退出");
}
}
Java 21 暂未提供 ScheduledExecutorService 的虚拟线程实现，可通过'平台线程定时调度 + 虚拟线程执行任务'的方式实现定时任务的高并发处理：
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class VirtualThreadScheduledDemo {
public static void main(String[] args) throws InterruptedException {
// 1. 平台线程池（用于定时调度，仅需少量线程）
ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
// 2. 虚拟线程池（用于执行实际定时任务，支撑高并发）
try (var taskExecutor = Executors.newVirtualThreadPerTaskExecutor()) {
// 3. 定时任务：每 1 秒执行一次，延迟 1 秒启动
scheduler.scheduleAtFixedRate(() -> {
// 提交任务到虚拟线程池执行
taskExecutor.submit(() -> {
System.out.printf("定时任务执行中，时间：%s，虚拟线程名称：%s%n",
System.currentTimeMillis(), Thread.currentThread().getName());
try {
TimeUnit.MILLISECONDS.sleep(500); // 模拟任务执行
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}, 1, 1, TimeUnit.SECONDS);
// 主线程等待 10 秒后关闭定时调度
TimeUnit.SECONDS.sleep(10);
scheduler.shutdown();
System.out.println("定时调度已关闭");
}
System.out.println("虚拟线程池已关闭，主线程退出");
}
}
Spring Boot 3.2+ 正式支持虚拟线程，可轻松将 Web 服务、异步任务切换为虚拟线程，无需修改业务代码。
依赖配置（pom.xml）：
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.0</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
修改 application.properties 或 application.yml，将 Tomcat/Jetty 的线程池切换为虚拟线程：
# application.yml
spring:
# 配置 Tomcat 使用虚拟线程
tomcat:
threads:
virtual: true
# 或配置 Jetty 使用虚拟线程（若使用 Jetty 容器）
# jetty:
# threads:
# virtual: true
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.TimeUnit;
@SpringBootApplication
@RestController
public class SpringBootVirtualThreadDemo {
public static void main(String[] args) {
SpringApplication.run(SpringBootVirtualThreadDemo.class, args);
}
// 高并发接口，自动使用虚拟线程处理
@GetMapping("/api/hello")
public String hello() throws InterruptedException {
// 模拟 I/O 阻塞（如数据库查询、RPC 调用）
TimeUnit.MILLISECONDS.sleep(200);
return String.format("Hello, Virtual Thread! 线程名称：%s，是否为虚拟线程：%b",
Thread.currentThread().getName(), Thread.currentThread().isVirtual());
}
}
通过 @Async 注解结合虚拟线程池，实现异步任务的高并发处理：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
@SpringBootApplication
@EnableAsync // 开启异步注解支持
@RestController
public class SpringBootVirtualThreadAsyncDemo {
public static void main(String[] args) {
SpringApplication.run(SpringBootVirtualThreadAsyncDemo.class, args);
}
// 配置虚拟线程池作为异步任务执行器
@Bean("virtualThreadExecutor")
public Executor virtualThreadExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
// 设置任务提交时使用虚拟线程
executor.setThreadFactory(Thread.ofVirtual().name("async-virtual-thread-").factory());
executor.setTaskDecorator(runnable -> runnable);
executor.initialize();
return executor;
}
// 异步方法，使用虚拟线程池执行
@Async("virtualThreadExecutor")
public void asyncTask() throws InterruptedException {
System.out.printf("异步任务执行中，线程名称：%s，是否为虚拟线程：%b%n",
Thread.currentThread().getName(), Thread.currentThread().isVirtual());
TimeUnit.MILLISECONDS.sleep(500);
System.out.println("异步任务执行完成");
}
// 调用异步任务的接口
@GetMapping("/api/async")
public String async() throws InterruptedException {
asyncTask();
return "异步任务已提交";
}
}
InheritableThreadLocal（仅适用于父子线程传递）或避免在虚拟线程中大量使用 ThreadLocal。join()、interrupt()（除非特殊场景），由 JVM 自动管理，手动干预可能导致资源泄漏。synchronized、ReentrantLock）会加剧锁竞争，导致载体线程阻塞，建议使用无锁编程（CAS）或细粒度锁。jstack <pid> 可查看虚拟线程状态（标记为 VirtualThread）；监控工具（Prometheus、SkyWalking）需升级到支持 Java 21 的版本，确保能正确采集虚拟线程指标。Thread.startVirtualThread()，自定义属性用 Thread.ofVirtual()，有返回值任务用 Executors.newVirtualThreadPerTaskExecutor()+Future。Executors.newVirtualThreadPerTaskExecutor() 虚拟线程池，无需配置线程数，支持自动关闭。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online