怎么利用 Project Loom 的虚拟线程池重构高并发阻塞式 IO 应用以提升单机吞吐量

高并发阻塞式IO应用通常面临平台线程资源紧张的问题，传统线程模型下每个请求对应一个平台线程，线程创建、上下文切换和内存占用的成本会随并发量上升快速增加，成为单机吞吐量提升的主要瓶颈。Project Loom引入的虚拟线程是运行在平台线程上的轻量级线程，创建成本极低，非常适合阻塞式IO场景的优化。

传统线程模型在高并发阻塞IO场景的瓶颈

传统Java应用中使用ThreadPoolExecutor管理平台线程，平台线程与操作系统线程一一对应，默认栈大小约1MB，单个JVM能创建的线程数量通常在数千级别。当应用处理大量阻塞式IO操作（如数据库查询、远程接口调用、文件读写）时，平台线程会在IO等待期间被阻塞，无法处理其他请求，若要支撑更高并发就需要创建更多平台线程，进而带来更高的内存开销和上下文切换成本，最终限制单机吞吐量。

Project Loom虚拟线程池核心原理

虚拟线程是Java 19正式引入的预览特性，Java 21成为正式功能，它由JVM调度而非操作系统调度，多个虚拟线程可以挂载到同一个平台线程上运行。当虚拟线程执行阻塞式IO操作时，JVM会自动将其从平台线程上卸载，平台线程可以继续运行其他虚拟线程，IO操作完成后虚拟线程会被重新调度到平台线程上继续执行。这种机制下，虚拟线程的创建、切换成本远低于平台线程，单个JVM可以轻松创建百万级别的虚拟线程，非常适合高并发阻塞IO场景。

重构高并发阻塞式IO应用的步骤

1. 环境准备

首先需要确保JDK版本为21及以上，Maven项目可以在pom.xml中配置编译版本：

<properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
</properties>

2. 替换传统线程池为虚拟线程池

Java 21提供了Executors.newVirtualThreadPerTaskExecutor()方法创建虚拟线程池，它会为每个提交的任务创建一个虚拟线程，无需额外配置线程数量。如果原有应用使用自定义ThreadPoolExecutor，可以直接替换为虚拟线程池，也可以根据需求封装自定义虚拟线程池。

原有传统线程池代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class OldThreadPoolDemo {
    // 传统固定大小平台线程池
    private static final ExecutorService PLATFORM_POOL = new ThreadPoolExecutor(
        200,  // 核心线程数
        200,  // 最大线程数
        0L,
        java.util.concurrent.TimeUnit.MILLISECONDS,
        new java.util.concurrent.LinkedBlockingQueue<>()
    );

    public static void handleRequest(Runnable task) {
        PLATFORM_POOL.submit(task);
    }
}

重构后的虚拟线程池代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class VirtualThreadPoolDemo {
    // 虚拟线程池，无需配置线程数量
    private static final ExecutorService VIRTUAL_POOL = Executors.newVirtualThreadPerTaskExecutor();

    public static void handleRequest(Runnable task) {
        VIRTUAL_POOL.submit(task);
    }
}

3. 适配阻塞式IO逻辑

虚拟线程对阻塞式IO操作有原生支持，原有使用InputStream、OutputStream、Socket、JDBC等阻塞API的代码无需修改，直接运行在虚拟线程上即可获得性能提升。如果原有代码使用了CompletableFuture等异步编程模型，也可以保留，虚拟线程会兼容这些逻辑。

示例：阻塞式数据库查询逻辑无需修改

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class DbQueryService {
    public String queryUserName(int userId) {
        // 阻塞式JDBC查询，在虚拟线程上执行时不会阻塞平台线程
        try (Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "123456");
             PreparedStatement ps = conn.prepareStatement("select name from user where id = ?")) {
            ps.setInt(1, userId);
            ResultSet rs = ps.executeQuery();
            if (rs.next()) {
                return rs.getString("name");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

4. 调整线程相关配置

如果原有应用有线程局部变量（ThreadLocal）的使用，需要注意虚拟线程的ThreadLocal行为和平台线程一致，但如果使用大量InheritableThreadLocal需要验证兼容性。另外不需要再配置平台线程相关的参数，如核心线程数、最大线程数、队列大小等，虚拟线程池会自动管理调度。

性能对比测试

可以通过模拟高并发阻塞IO请求测试重构前后的性能差异，以下是一个简单的压测示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class ThroughputTest {
    // 模拟阻塞IO操作，休眠100ms
    private static void mockBlockIo() {
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void test(ExecutorService pool, int concurrency) throws Exception {
        CountDownLatch latch = new CountDownLatch(concurrency);
        long start = System.currentTimeMillis();
        for (int i = 0; i < concurrency; i++) {
            pool.submit(() -> {
                mockBlockIo();
                latch.countDown();
            });
        }
        latch.await();
        long cost = System.currentTimeMillis() - start;
        System.out.println("并发量：" + concurrency + "，耗时：" + cost + "ms，吞吐量：" + (concurrency * 1000L / cost) + "请求/秒");
        pool.close();
    }

    public static void main(String[] args) throws Exception {
        // 测试传统平台线程池，核心线程200
        ExecutorService platformPool = new ThreadPoolExecutor(200, 200, 0L, TimeUnit.MILLISECONDS, new java.util.concurrent.LinkedBlockingQueue<>());
        test(platformPool, 10000);

        // 测试虚拟线程池
        ExecutorService virtualPool = Executors.newVirtualThreadPerTaskExecutor();
        test(virtualPool, 10000);
    }
}

在10万并发、每个请求阻塞100ms的场景下，传统平台线程池受限于200个核心线程，吞吐量约为2000请求/秒，而虚拟线程池可以轻松支撑所有并发，吞吐量可达近10000请求/秒，单机性能提升明显。

注意事项

• 虚拟线程不适合CPU密集型任务，因为CPU密集型任务会一直占用平台线程，无法发挥虚拟线程的调度优势，这类任务仍建议使用传统平台线程池。
• 避免在虚拟线程中执行长时间运行的同步代码块，尤其是持有锁的同步代码，可能会导致虚拟线程无法及时卸载，影响调度效率。
• 部分旧的第三方库可能没有适配虚拟线程，如果在使用过程中出现兼容性问题，可以排查是否有不合理的线程绑定逻辑。

Project_Loom虚拟线程池高并发阻塞式_IO单机吞吐量修改时间：2026-06-16 04:33:15