在Java 21中，引入了虚拟线程，这是一个非常非常重要的特性，之前一直苦苦寻找的Java协程，终于问世了。在高并发以及IO密集型的应用中，虚拟线程能极大的提高应用的性能和吞吐量。
什么是虚拟线程
先来看一下虚拟线程的概念。
虚拟线程概念
DK 21 引入了虚拟线程的支持，这是为了改善 Java 应用程序在高并发场景下的性能。虚拟线程是一种轻量级线程，具有较小的内存占用，能够更高效地进行上下文切换，适用于 I/O 密集型的应用程序。
虚拟线程的工作原理
当应用程序启动一个虚拟线程时，JVM会将这个虚拟线程交给JVM底层的线程池去执行，这个底层的线程池是一个传统线程池，并且真正执行虚拟线程中任务的线程，也是传统线程（操作系统线程）。当虚拟线程遇到阻塞时，JVM会立刻将虚拟线程挂起，让其它虚拟线程执行。也就是说，开启一个虚拟线程，并不需要启用一个传统线程，一般一个传统线程，可以执行多个虚拟线程的任务。在执行过程中，可以把虚拟线程理解成任务task。
这里举一个列子，假设用户创建了1000个虚拟线程，JVM的执行虚拟线程的线程池线程数是10，那么当第一个虚拟线程V1需要执行时，JVM会将V1调度到传统线程T1上，以此类推，虚拟线程V2会被调度到传统线程T2上，那么V3->T3，V4->T4，… V10->T10。当执行到V11时，这里有三种情况：
-
如果V1~V10中有任何一个线程遇到阻塞，我们这里假设V3遇到阻塞，那么JVM会将V3挂起，此时T3线程可用，那么V11被T3执行。
-
如果V1~V10没有线程被阻塞，那么JVM根据划分的时间片，假设每个虚拟线程允许执行100ns，那么过了100ns后，这里V1最新执行，JVM则将V1挂起，让T1去执行V11。
-
如果以上两种情况都不满足，那么先将V11挂起，等待有可用的传统线程时，再执行V11。
对于被阻塞的线程，如V3，当IO结束后，操作系统会通过事件，如epoll通知JVM，V3的IO操作已结束，此时JVM重新唤醒V3，选择可用的传统线程，来执行V3的任务。
这里需要注意两点：
-
**虚拟线程IO执行完成后，会通过操作系统的事件通知机制，如epoll来通知JVM。**这一点对于虚拟线程的高效调度至关重要，因为它确保了 阻塞的 I/O 操作 不会占用操作系统线程的时间片，避免了传统线程池的高资源消耗和效率低下。。
-
JVM在对虚拟线程进行上下文切换时，因为不涉及到操作系统级别的线程上下文切换，代价非常低，速度也非常快。
虚拟线程的调度
一般来说，程序员不需要对虚拟线程的调度进行管理，在JDK 21中，JVM默认启用了虚拟线程，并且会使用默认的ForkJoinPool线程池来执行虚拟线程，并且线程池的大小，也会根据虚拟线程的数量，进行动态调整。如果需要手动管理执行虚拟线程的线程池大小，那么需要自定义线程池，并将虚拟线程交给自定义的线程池来执行，这样虽然可行，通常没有必要。
虚拟线程与传统线程区别
虚拟线程与传统线程的区别主要在于：
-
创建虚拟线程时，JVM不会创建一个操作系统线程，创建一个传统线程时，JVM会创建一个操作系统线程。一个传统线程，可以轮询执行多个虚拟线程。
-
虚拟线程是由传统线程来执行的，虚拟线程的调度由JVM控制，传统线程的执行和调度，由操作系统来控制。
-
虚拟线程的上下文切换是由JVM控制的，因为不涉及到操作系统级别线程的上下文切换，虚拟线程上下文切换速度非常快，可以满足高并发需求。
-
创建一个虚拟线程占用的内存非常小，相对而言，创建一个传统线程，占用的内存空间大。在应用中，可以创建大量的虚拟线程，一般支持到百万级，而创建传统线程，一般只能到几千，我们一般也不建议创建这么多传统线程。
虚拟线程类似于task，传统系统与操作系统线程对应，一个传统线程可以执行多个虚拟线程。虚拟线程与task的区别是，当传统线程执行虚拟线程时，遇到阻塞会挂起虚拟线程，当传统线程执行task时，遇到阻塞就真的阻塞了。当然传统中的task继承自runnable，虚拟线程继承自Thread，他们属于不同的类，可调用的方法也不一样。
JDK也提供了虚拟线程池，可以通过下面方式得到一个虚拟线程池。
import java.util.concurrent.*;
public class VirtualThreadPoolExample {
public static void main(String[] args) {
// 创建一个虚拟线程池
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
// 提交多个任务到线程池
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " running in " + Thread.currentThread());
});
}
// 关闭线程池
executor.shutdown();
}
}
上面代码中，提交给线程池的任务，JVM都会为其创建一个虚拟线程，然后以虚拟线程的方式执行。
与传统的线程池相比，虚拟线程池无法设置核心线程数、最大线程数、线程池大小、任务队列等参数，也不需要设置这些参数。
虚拟线程与传统线程的相同之处：
-
他们都继承自Thread，用法一摸一样。也都支持线程池。
-
与传统一样，虚拟线程也有new，runnable，waiting，blocked，terminated等状态。
-
所有的锁，同步机制，对虚拟线程都适用，并且与传统线程一样，虚拟线程也会有资源争夺以及状态同步问题。并且也有上下文切换，虽然虚拟线程的上下文切换，代价非常小。
-
异常处理机制一样，如果遇到异常不处理，虚拟线程也会终止执行。
虚拟线程与协程的区别
协程是python中的异步编程技术，对于IO密集型应用，协程可以发挥很大的优势。协程的异步工作原理与虚拟线程相似，也是遇到IO就阻塞，让主线程继续执行其它任务，当IO完成时，操作系统通过事件机制，如epoll，通知python进程，产生一个事件，放到event loop队列中，最后由主线程执行。
虚拟线程与协程的主要区别在于：
| 区别 | 虚拟线程 | 协程 |
|--------|-------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------|
| 并发/并行 | 虚拟线程是并行的，多个虚拟线程可以同时在多个CPU上运行，同一时刻，可以运行多个虚拟线程。从这个角度将，虚拟线程能支持更高的并发。 | 协程不是并行的，因为只有一个主线程执行任务事件，同一时刻，只有一个任务被处理。 |
| 资源争夺 | 虚拟线程中，存在资源争夺问题，以及状态同步问题，在编写代码时，需要考虑并发控制。甚至需要做合理的并发设计。 | 因为只有一个主线程在执行任务事件，没有并发问题，编程时也不需要考虑并发问题。 |
| 框架支持 | 虚拟线程是JDK 21的新特性，不需要任何框架支持。 | 需要框架支持，写异步代码和同步代码，使用的是两个完全不同的框架，另外学习异步编程，增加了学习成本。并且异步编程有些难度，debug也变得复杂些。 |
怎样使用虚拟线程
在JDK 21中，使用虚拟线程有两种方式：
-
直接创建并启动虚拟线程。
public class VirtualThreadExample {
public static void main(String[] args) {
Thread virtualThread = Thread.ofVirtual().start(() -> {
System.out.println("Hello virtual thread ");
});
try {
virtualThread.join(); // 等待虚拟线程完成
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
-
通过线程池执行虚拟线程。
import java.util.concurrent.*;
public class VirtualThreadPoolExample {
public static void main(String[] args) {
// 创建一个虚拟线程池
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
// 提交多个任务到线程池
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " running in " + Thread.currentThread());
});
}
// 关闭线程池
executor.shutdown();
}
}
通过线程池执行任务时，无法对并发实现控制，容易造成OOM，或耗尽服务方资源，可以自定义以下虚拟线程池，实现资源控制：
package com.zengbiaobiao.demo.vitrualthreaddemo;
import org.springframework.lang.NonNull;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
/*****
* 虚拟线程池，支持配置任务队列数和最大并发任务数
*/
public class VirtualThreadExecutorService extends AbstractExecutorService {
private volatile boolean shouldStop = false;
private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
private final Semaphore semaphore;
private final BlockingQueue<Runnable> taskQueue;
/******
* 构造函数
* @param taskQueueSize，任务队列大小，任务队列是一个阻塞队列，如果任务队列满了，那么调用execute方法会阻塞
* @param concurrencySize，并发任务大小，同时执行的IO任务个数，防止并发过重，或者资源不够
*/
public VirtualThreadExecutorService(int taskQueueSize, int concurrencySize) {
this.semaphore = new Semaphore(concurrencySize);
taskQueue = new LinkedBlockingQueue<>(taskQueueSize);
this.loopEvent();
}
private void loopEvent() {
Thread.ofVirtual().name("VirtualThreadExecutor").start(() -> {
while (!shouldStop) {
try {
Runnable task = taskQueue.take();
semaphore.acquire();
executor.execute(() -> {
try {
try {
task.run();
} finally {
semaphore.release();
}
} catch (Exception e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
});
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
if (shouldStop) break;
}
}
});
}
@Override
public void shutdown() {
shouldStop = true;
executor.shutdown();
}
/**
* @return The task not executed
*/
@Override
public List<Runnable> shutdownNow() {
shouldStop = true;
List<Runnable> remainingTasks = new ArrayList<>(taskQueue);
taskQueue.clear();
executor.shutdownNow();
return remainingTasks;
}
@Override
public boolean isShutdown() {
return shouldStop;
}
@Override
public boolean isTerminated() {
return shouldStop && executor.isTerminated();
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
return executor.awaitTermination(timeout, unit);
}
@Override
public void execute(Runnable command) {
try {
taskQueue.put(command); // 阻塞直到队列有空间
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RejectedExecutionException("Task submission interrupted.", e);
}
}
}
测试代码如下：
package com.zengbiaobiao.demo.vitrualthreaddemo;
import org.apache.tomcat.util.threads.VirtualThreadExecutor;
public class VirtualThreadExecutorServiceDemo {
public static void main(String[] args) throws InterruptedException {
VirtualThreadExecutorService executorService = new VirtualThreadExecutorService(10, 2);
for (int i = 0; i < 100000; i++) {
final String threadName = "thread-" + i;
System.out.println(Thread.currentThread() + ": try to create task " + threadName);
executorService.submit(() -> {
System.out.println(Thread.currentThread() + ": " + threadName + " created!");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread() + ": " + threadName + " finished!");
});
}
Thread.sleep(5000000);
}
}
哪些场景下可以应用虚拟线程
虚拟线程在IO密集型的高并发应用中能发挥出巨大的威力，在所有IO密集型应用中，具体来说，下列场景中，使用虚拟线程是比较合适的：
-
短时间需要完成的任务，且没有资源争夺或乱序问题，比如数据库写入，服务器 HTTP 请求处理，远程 RESTful API 调用，RabbitMQ 消息处理等应用场景。。
-
长时间运行的任务，但是对消息处理由顺序要求的任务。比如在电梯监控系统中，需要对每台电梯的数据进行处理，但是需要保证消息被处理的顺序。这时可以为每台电梯创建一个虚拟线程，这台电梯的数据交给专门的虚拟线程处理。因为应用中可以创建大量虚拟线程，并且虚拟线程一般都是异步处理任务，所以这个场景中，使用虚拟线程，可以满足高性能和高并发的要求。
-
API网关中，对多个上游API数据进行查询，组装合并，使用虚拟线程，相比传统线程，效果更佳。虚拟线程，也支持CountDownLatch，Semaphore等工具类。
-
事件驱动的架构中，使用虚拟线程，效果也很好。比如spring boot中的异步事件，默认使用的是传统线程池，如果将其改成虚拟线程池，并发处理能力可以极大提高。
那么哪些场景下不合适使用虚拟线程呢？
-
CPU密集型应用，比如大数据处理、图像处理、矩阵运算等。
-
如果应用有很高的并发资源争夺，或者状态同步，并且造成系统吞吐量低，需要考虑优化并发模型，这种场景下，不但传统线程不合适，虚拟线程也不合适。
虚拟线程实际应用场景举例
在一个spring boot项目中，有时候因为异步事件处理不过来，造成吞吐量下降，在JDK 21中，可以将事件改成虚拟线程来执行，代码如下：
package com.zengbiaobiao.demo.vitrualthreaddemo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean(name = "taskExecutor")
public Executor taskExecutor() {
// 最大并行任务数
Semaphore semaphore = new Semaphore(100);
ExecutorService virtualThreadPool = Executors.newVirtualThreadPerTaskExecutor();
return runnable -> {
try {
// 控制并行任务数
semaphore.acquire();
virtualThreadPool.submit(() -> {
try {
runnable.run();
} finally {
semaphore.release();
}
});
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Task submission interrupted", e);
}
};
}
}
事件发送和处理代码如下：
package com.zengbiaobiao.demo.vitrualthreaddemo;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/home")
public class HomeController {
private final ApplicationEventPublisher eventPublisher;
public HomeController(ApplicationEventPublisher eventPublisher) {
this.eventPublisher = eventPublisher;
}
@GetMapping("/index")
public String index() {
for (int i = 0; i < 1000; i++) {
eventPublisher.publishEvent("event " + i);
}
return "success";
}
@EventListener
@Async
public void handleEvent(String event) {
System.out.println(Thread.currentThread() + ": " + event);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
输出结果如下：
VirtualThread[#2031]/runnable@ForkJoinPool-1-worker-4: event 976
VirtualThread[#2039]/runnable@ForkJoinPool-1-worker-1: event 980
VirtualThread[#1064]/runnable@ForkJoinPool-1-worker-1: event 983
VirtualThread[#2047]/runnable@ForkJoinPool-1-worker-2: event 984
VirtualThread[#2049]/runnable@ForkJoinPool-1-worker-9: event 985
VirtualThread[#2057]/runnable@ForkJoinPool-1-worker-2: event 989
VirtualThread[#2059]/runnable@ForkJoinPool-1-worker-3: event 990
VirtualThread[#2061]/runnable@ForkJoinPool-1-worker-6: event 991
VirtualThread[#2063]/runnable@ForkJoinPool-1-worker-10: event 992
VirtualThread[#2065]/runnable@ForkJoinPool-1-worker-10: event 993
VirtualThread[#2071]/runnable@ForkJoinPool-1-worker-3: event 996
VirtualThread[#2069]/runnable@ForkJoinPool-1-worker-2: event 995
VirtualThread[#2075]/runnable@ForkJoinPool-1-worker-7: event 998
VirtualThread[#2077]/runnable@ForkJoinPool-1-worker-10: event 999
上面输出结果中，每次并发执行100个任务，当虚拟线程池任务达到100之后，执行eventPublisher.publishEvent("event " + i)代码时，代码阻塞，过100ms之后，100个任务执行完成，下一批任务被执行。
虚拟线程使用注意事项
-
搞清楚任务类型，是IO密集型，还是CPU密集型
-
与传统线程结合使用
-
关注性能和资源，使用虚拟线程无法通过线程池等工具控制并发，需要借助Semepha，CountdownLatch等工具才能限流，如果不限流，容易造成OOM，或对目标系统造成巨大流量冲击。
-
**在异步框架中，关注隐藏的传统线程，**比如在HttpClient的异步请求中，每次异步请求都会创建一个HttpClient回调线程。大量的传统线程被间接创建，也容易引起OOM。
-
由synchronized关键字引起的pinned问题，看起来在JDK 21中，做了一些优化，即便虚拟线程pinned到传统线程，也只是性能退回到传统线程，无非是慢一点，反而不是太大问题。经过大量测试，发现基本只出现一次，之后不会再出现。不过使用ReentrantLock，效果确实会好很多，将synchronized关键字改成lock.()和lock.unlock()，ForkJoinPool中的线程数量会降低，并且任务分配均衡。
-
不要忽略软件设计，尤其在需要大量同步的应用中。
经过验证，**虚拟线程在遇到IO时，确实会让步，并且不消耗太多资源，核心特点是，让异步编程变得简单，并且不需要框架支持。但是容易因大的并发，造成OOM，或者对目标系统造成冲击，追求高并发可用，但一定要做测试和验证。**对于需要做状态同步，如需要加锁，或需要使用synchronize关键字的代码，需要优化设计，如果无法规避，那么，使用虚拟线程，和使用线程池，效果差不多。
虚拟线程存在的问题：
Java Virtual Threads — some early gotchas to look out for
Two Pitfalls by moving to Java Virtual Threads
Java 21 Virtual Threads - Dude, Where’s My Lock?
Pitfalls to avoid when switching to Virtual threads
Do Java 21 virtual threads address the main reason to switch to reactive single-thread frameworks?
Pinning: A pitfall to avoid when using virtual threads in Java
Taming the Virtual Threads: Embracing Concurrency With Pitfall Avoidance
Pitfalls you encounter with virtual threads
