Java SE 19 虚拟线程
作者：互联网
说明#
虚拟线程（Virtual Threads）是在Project Loom中开发的，并从 Java SE 19 开始作为预览功能引入 JDK。
在线程模型下，一个 Java 线程相当于一个操作系统线程，而这些线程是很消耗资源的，如果启动的线程过多，会给整个系统的稳定性带来风险。
虚拟线程解决了这个问题，从 Java 代码的角度来看，虚拟线程感觉就像普通的线程，但它们不是 1:1 地映射到操作系统线程上。
有一个所谓的载体线程池，一个虚拟线程被临时映射到该池中。一旦虚拟线程遇到阻塞操作，该虚拟线程就会从载体线程中移除，而载体线程可以执行另一个虚拟线程（新的或之前被阻塞的）。
所以阻塞的操作不再阻塞执行的线程。这使得我们可以用一个小的载体线程池来并行处理大量的请求。
示例#
场景
启动 1000 个任务，每个任务等待一秒钟（模拟访问外部API），然后返回一个结果（在这个例子中是一个随机数）。
任务类如下
package git.snippets.vt;
import java.util.concurrent.Callable;
import java.util.concurrent.ThreadLocalRandom;
/**
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/21
* @since 19
*/
public class Task implements Callable<Integer> {
private final int number;
public Task(int number) {
this.number = number;
}
@Override
public Integer call() {
System.out.printf("Thread %s - Task %d waiting...%n", Thread.currentThread().getName(), number);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.printf("Thread %s - Task %d canceled.%n", Thread.currentThread().getName(), number);
return -1;
}
System.out.printf("Thread %s - Task %d finished.%n", Thread.currentThread().getName(), number);
return ThreadLocalRandom.current().nextInt(100);
}
}
接下来，我们测试使用线程池开启 100 个线程处理 1000 个任务需要多长时间。
package git.snippets.vt;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/21
* @since 19
*/
public class App {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(100);
List<Task> tasks = new ArrayList<>();
for (int i = 0; i < 1_000; i++) {
tasks.add(new Task(i));
}
long time = System.currentTimeMillis();
List<Future<Integer>> futures = executor.invokeAll(tasks);
long sum = 0;
for (Future<Integer> future : futures) {
sum += future.get();
}
time = System.currentTimeMillis() - time;
System.out.println("sum = " + sum + "; time = " + time + " ms");
executor.shutdown();
}
}
运行结果如下
Thread pool-1-thread-1 - Task 0 waiting...
Thread pool-1-thread-3 - Task 2 waiting...
Thread pool-1-thread-2 - Task 1 waiting...
……
sum = 49879; time = 10142 ms
接下来，我们用虚拟线程测试整个事情。因此，我们只需要替换这一行
ExecutorService executor = Executors.newFixedThreadPool(100);
替换为
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
执行效果如下
Thread - Task 0 waiting...
Thread - Task 2 waiting...
Thread - Task 3 waiting...
……
sum = 48348; time = 1125 ms
1125 ms VS 10142 ms，性能提升非常明显。
注：本示例需要在 JDK 19 下运行，且需要增加 --enable-preview 参数，在 IDEA 下，这个参数配置
我们已经了解了创建虚拟线程的一种方法：使用Executors.newVirtualThreadPerTaskExecutor()创建的执行器服务，为每个任务创建一个新的虚拟线程。
使用Thread.startVirtualThread()或Thread.ofVirtual().start()，我们也可以明确地启动虚拟线程。
虚拟线程（Virtual Threads）是在Project Loom中开发的，并从 Java SE 19 开始作为预览功能引入 JDK。
在线程模型下，一个 Java 线程相当于一个操作系统线程，而这些线程是很消耗资源的，如果启动的线程过多，会给整个系统的稳定性带来风险。
虚拟线程解决了这个问题，从 Java 代码的角度来看，虚拟线程感觉就像普通的线程，但它们不是 1:1 地映射到操作系统线程上。
有一个所谓的载体线程池，一个虚拟线程被临时映射到该池中。一旦虚拟线程遇到阻塞操作，该虚拟线程就会从载体线程中移除，而载体线程可以执行另一个虚拟线程（新的或之前被阻塞的）。
所以阻塞的操作不再阻塞执行的线程。这使得我们可以用一个小的载体线程池来并行处理大量的请求。
示例#
场景
启动 1000 个任务，每个任务等待一秒钟（模拟访问外部API），然后返回一个结果（在这个例子中是一个随机数）。
任务类如下
package git.snippets.vt;
import java.util.concurrent.Callable;
import java.util.concurrent.ThreadLocalRandom;
/**
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/21
* @since 19
*/
public class Task implements Callable<Integer> {
private final int number;
public Task(int number) {
this.number = number;
}
@Override
public Integer call() {
System.out.printf("Thread %s - Task %d waiting...%n", Thread.currentThread().getName(), number);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.printf("Thread %s - Task %d canceled.%n", Thread.currentThread().getName(), number);
return -1;
}
System.out.printf("Thread %s - Task %d finished.%n", Thread.currentThread().getName(), number);
return ThreadLocalRandom.current().nextInt(100);
}
}
接下来，我们测试使用线程池开启 100 个线程处理 1000 个任务需要多长时间。
package git.snippets.vt;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/21
* @since 19
*/
public class App {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(100);
List<Task> tasks = new ArrayList<>();
for (int i = 0; i < 1_000; i++) {
tasks.add(new Task(i));
}
long time = System.currentTimeMillis();
List<Future<Integer>> futures = executor.invokeAll(tasks);
long sum = 0;
for (Future<Integer> future : futures) {
sum += future.get();
}
time = System.currentTimeMillis() - time;
System.out.println("sum = " + sum + "; time = " + time + " ms");
executor.shutdown();
}
}
运行结果如下
Thread pool-1-thread-1 - Task 0 waiting...
Thread pool-1-thread-3 - Task 2 waiting...
Thread pool-1-thread-2 - Task 1 waiting...
……
sum = 49879; time = 10142 ms
接下来，我们用虚拟线程测试整个事情。因此，我们只需要替换这一行
ExecutorService executor = Executors.newFixedThreadPool(100);
替换为
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
执行效果如下
Thread - Task 0 waiting...
Thread - Task 2 waiting...
Thread - Task 3 waiting...
……
sum = 48348; time = 1125 ms
1125 ms VS 10142 ms，性能提升非常明显。
注：本示例需要在 JDK 19 下运行，且需要增加 --enable-preview 参数，在 IDEA 下，这个参数配置
我们已经了解了创建虚拟线程的一种方法：使用Executors.newVirtualThreadPerTaskExecutor()创建的执行器服务，为每个任务创建一个新的虚拟线程。
使用Thread.startVirtualThread()或Thread.ofVirtual().start()，我们也可以明确地启动虚拟线程。