如何控制java虚拟线程的并发度？

jdk 21中的虚拟线程已经推出好一段时间了，确实很轻量，先来一段示例：

假如有一段提交订单的业务代码：

    public void submitOrder(Integer orderId) {
        sleep(1000);
        System.out.println("order:" + orderId + " is submitted");
    }

这里我们用sleep来模拟，每提交1个订单，大致耗时1秒。

如果有10个订单一起下单，顺序执行的话，至少10秒，很容易想到用多线程：

    @Test
    public void submitOrder1() {
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("submitOrder-pool-%d").build();
        ExecutorService submitOrderPool = new ThreadPoolExecutor(4, 16, 300L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(128), threadFactory, new ThreadPoolExecutor.DiscardOldestPolicy());
        CompletableFuture<Void>[] futures = new CompletableFuture[10];
        StopWatch watch = new StopWatch();
        watch.start();
        //下10个订单
        for (int i = 0; i < 10; i++) {
            final int orderId = i;
            CompletableFuture<Void> future = CompletableFuture.runAsync(() -> submitOrder(orderId), submitOrderPool);
            futures[i] = future;
        }
        CompletableFuture.allOf(futures).join();
        watch.stop();
        System.out.println("Time: " + watch.getTime());
    }

这里我们使用了传统的线程池，核心线程数是4，小于10，所以会内部排队，最终执行效果大致如下：

order:0 is submitted
order:3 is submitted
order:1 is submitted
order:2 is submitted
order:4 is submitted
order:6 is submitted
order:7 is submitted
order:5 is submitted
order:8 is submitted
order:9 is submitted
Time: 3035

明显快多了，但是占用了4个传统的java线程。

 

我们改用虚拟线程来改写：

    @Test
    public void submitOrder2() {
        CompletableFuture<Void>[] futures = new CompletableFuture[10];
        StopWatch watch = new StopWatch();
        watch.start();
        //下10个订单(这里使用虚拟线程)
        try (ExecutorService service = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10; i++) {
                final int orderId = i;
                CompletableFuture<Void> future = CompletableFuture.runAsync(() -> submitOrder(orderId), service);
                futures[i] = future;
            }
            CompletableFuture.allOf(futures).join();
        }
        watch.stop();
        System.out.println("Time: " + watch.getTime());
    }

运行效果：

order:1 is submitted
order:3 is submitted
order:2 is submitted
order:4 is submitted
order:8 is submitted
order:9 is submitted
order:0 is submitted
order:5 is submitted
order:7 is submitted
order:6 is submitted
Time: 1035

对原有代码仅做了轻微改动，就能享受到虚拟线程的好处，占用资源更小，整体耗时更低，看上很完美！但真的这么丝滑吗？

 

这里有一个坑：正所谓“成也萧何，败也萧何”，虚拟线程这种轻量性的机制，导致它创建起来成本太低了，完全没有池化的必要，1台机器轻轻松松就可以瞬间创建上万甚至上百成的虚拟线程。相比传统的线程池机制（有coreSize,maxSize,workQueue缓冲，以及各种policy策略兜底），虚拟线程完全没有并发度控制的概念，如果瞬间生成大量的虚拟线程，每个里都是执行db/redis操作，很容易就把db、redis连接池打爆！！！

 

因此，实际生产应用中，强烈建议大家控制虚拟线程的执行并发数！！！

可以参考下面的做法，使用信号量来约束：

    @Test
    public void submitOrder3() {
        CompletableFuture<Void>[] futures = new CompletableFuture[10];
        StopWatch watch = new StopWatch();
        watch.start();
        //下10个订单
        try (ExecutorService service = Executors.newVirtualThreadPerTaskExecutor()) {
            //限制并发数为4
            final Semaphore POOL = new Semaphore(4);
            for (int i = 0; i < 10; i++) {
                final int orderId = i;
                CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
                    try {
                        //获取信号量（注:信号量用完了，后面的任务就只能等着）
                        POOL.acquire();
                        submitOrder(orderId);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //执行完后，释放信号量
                        POOL.release();
                    }
                }, service);
                futures[i] = future;
            }
            CompletableFuture.allOf(futures).join();
        }
        watch.stop();
        System.out.println("Time: " + watch.getTime());
    }

order:2 is submitted
order:1 is submitted
order:0 is submitted
order:3 is submitted
order:4 is submitted
order:5 is submitted
order:8 is submitted
order:9 is submitted
order:7 is submitted
order:6 is submitted
Time: 3042

 

参考文档：
https://blog.moyucoding.com/jvm/2023/09/23/ultimate-guide-to-java-virtual-thread

https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html#GUID-DC4306FC-D6C1-4BCC-AECE-48C32C1A8DAA

https://www.didispace.com/article/java-21-virtaul-threads.html