Java虚拟线程下实现递归任务：告别Fork/Join的替代方案与实践

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public record PseudoTask(int from, int to) {
    public static CompletableFuture<Void> run(int from, int to) {
        // 使用Thread::startVirtualThread在虚拟线程中执行任务
        return CompletableFuture.runAsync(
            new PseudoTask(from, to)::compute, Thread::startVirtualThread);
    }

    protected void compute() {
        int mid = (from + to) >>> 1;
        if (mid == from) {
            // 模拟实际的阻塞操作，例如耗时计算或I/O
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(500));
        } else {
            // 递归地创建并运行子任务
            CompletableFuture<Void> sub1 = run(from, mid);
            CompletableFuture<Void> sub2 = run(mid, to);
            // 等待子任务完成。注意：join()会阻塞当前虚拟线程
            sub1.join();
            sub2.join();
        }
    }

    public static void main(String[] args) {
        System.out.println("Starting recursive task with virtual threads...");
        long startTime = System.currentTimeMillis();
        PseudoTask.run(0, 1_000).join(); // 启动并等待根任务完成
        long endTime = System.currentTimeMillis();
        System.out.println("Recursive task completed in " + (endTime - startTime) + " ms");
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public record OptimizedPseudoTask(int from, int to) {
    public static CompletableFuture<Void> run(int from, int to) {
        return CompletableFuture.runAsync(
            new OptimizedPseudoTask(from, to)::compute, Thread::startVirtualThread);
    }

    protected void compute() {
        CompletableFuture<Void> pendingFutures = null;
        // 循环处理一部分任务，另一部分提交给新线程
        for (int currentFrom = this.from; ; currentFrom = (currentFrom + to) >>> 1) {
            int mid = (currentFrom + to) >>> 1;
            if (mid == currentFrom) {
                // 模拟实际的阻塞操作
                LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(500));
                break; // 达到基本任务单元
            } else {
                // 将一半任务提交给新的虚拟线程
                CompletableFuture<Void> subTaskFuture = run(currentFrom, mid);
                if (pendingFutures == null) {
                    pendingFutures = subTaskFuture;
                } else {
                    pendingFutures = CompletableFuture.allOf(pendingFutures, subTaskFuture);
                }
                // 当前虚拟线程继续处理另一半任务（通过循环迭代）
            }
        }
        // 等待所有提交的子任务完成
        if (pendingFutures != null) {
            pendingFutures.join();
        }
    }

    public static void main(String[] args) {
        System.out.println("Starting optimized recursive task with virtual threads...");
        long startTime = System.currentTimeMillis();
        OptimizedPseudoTask.run(0, 1_000_000).join(); // 启动并等待根任务完成
        long endTime = System.currentTimeMillis();
        System.out.println("Optimized recursive task completed in " + (endTime - startTime) + " ms");
    }
}

import jdk.incubator.concurrent.StructuredTaskScope; // 注意：这是孵化器API
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public record StructuredPseudoTask(int from, int to) {
    public static void run(int from, int to) {
        // 使用ShutdownOnFailure策略，任何子任务失败都会导致整个范围关闭
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            new StructuredPseudoTask(from, to).compute(scope);
            scope.join(); // 等待所有在scope内fork的子任务完成
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
            throw new IllegalStateException("Task interrupted", e);
        }
    }

    protected Void compute(StructuredTaskScope<Object> scope) {
        for (int currentFrom = this.from; ; currentFrom = (currentFrom + to) >>> 1) {
            int mid = (currentFrom + to) >>> 1;
            if (mid == currentFrom) {
                // 模拟实际的阻塞操作
                LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(500));
                break; // 达到