Java 21中何时选择Platform Threads而非Virtual Threads？

Java 21的虚拟线程（Virtual Threads）确实在IO密集型场景下带来了极强的可扩展性，但在以下几种特定场景中，直接使用平台线程（Platform Threads）仍是更优甚至唯一的选择：

1. 执行CPU密集型、无阻塞的长时计算任务 #

虚拟线程的核心优势在于IO阻塞时主动让出载体平台线程，但对于持续占用CPU、无任何阻塞操作的任务，虚拟线程无法发挥调度优势，反而会一直占用载体线程，导致载体线程池被耗尽，影响其他任务的执行。此时使用固定大小的平台线程池（匹配CPU核心数）能更高效地利用CPU资源。

示例：大质数计算 #

假设需要批量计算多个大整数的质因数分解，这类任务完全依赖CPU，无任何IO或阻塞操作：

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

public class CpuIntensiveTaskExample {
    // 判断是否为质数（模拟CPU密集型任务）
    private static boolean isPrime(long num) {
        if (num <= 1) return false;
        for (long i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) return false;
        }
        return true;
    }

    public static void main(String[] args) throws InterruptedException {
        // 最优选择：使用匹配CPU核心数的平台线程池
        ExecutorService platformThreadPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        
        // 如果改用虚拟线程池：Executors.newVirtualThreadPerTaskExecutor()
        // 当任务数量超过CPU核心数时，虚拟线程会抢占载体线程，导致上下文切换开销飙升，整体计算效率下降

        long[] largeNumbers = {999999937L, 1000000007L, 1000000009L, 1000000021L, 1000000033L};
        
        for (long num : largeNumbers) {
            platformThreadPool.submit(() -> {
                System.out.printf("数字 %d 是否为质数：%b%n", num, isPrime(num));
            });
        }

        platformThreadPool.shutdown();
        platformThreadPool.awaitTermination(1, TimeUnit.MINUTES);
    }
}

原因分析：平台线程池的大小固定为CPU核心数，能让CPU保持满负载运行，避免不必要的线程上下文切换；而虚拟线程池会为每个任务创建虚拟线程，当任务数超过核心数时，多个虚拟线程会争抢同一个载体线程的CPU时间片，反而增加调度开销，降低整体计算效率。

2. 需要绑定特定操作系统线程的本地（JNI）调用 #

部分第三方本地库（如某些硬件驱动、图形渲染库、老版本的JNI组件）要求线程绑定：即调用必须始终在同一个操作系统线程上执行，否则会导致本地库的状态错乱（比如线程本地存储的资源未正确释放、上下文丢失）。虚拟线程可能被调度到不同的平台线程上，无法满足这种绑定要求。

示例：绑定线程的JNI硬件交互 #

假设我们有一个控制工业传感器的JNI库，要求所有调用必须在同一个线程上执行：

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

public class JniThreadBindingExample {
    // 加载JNI库
    static {
        System.loadLibrary("SensorController");
    }

    // JNI方法：初始化传感器（要求在固定线程执行）
    private native void initSensor();
    // JNI方法：读取传感器数据（要求与initSensor在同一线程执行）
    private native double readSensorData();

    public static void main(String[] args) {
        // 必须使用单线程的平台线程池，确保所有JNI调用在同一个平台线程执行
        ExecutorService singlePlatformThread = Executors.newSingleThreadExecutor();
        
        // 如果改用虚拟线程：每次调用可能被调度到不同的平台线程，JNI库会抛出状态错误
        JniThreadBindingExample example = new JniThreadBindingExample();

        singlePlatformThread.submit(() -> {
            example.initSensor();
            for (int i = 0; i < 5; i++) {
                double data = example.readSensorData();
                System.out.printf("传感器数据：%.2f%n", data);
                try {
                    Thread.sleep(1000); // 模拟采样间隔
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        singlePlatformThread.shutdown();
    }
}

原因分析：单线程平台线程池能保证所有JNI调用都在同一个操作系统线程上执行，符合本地库的线程绑定要求；而虚拟线程的调度是由JVM动态分配载体线程的，无法保证连续调用在同一平台线程上执行，会触发本地库的线程安全问题。

3. 需要严格控制线程优先级的实时任务 #

虚拟线程的优先级会被JVM忽略（因为虚拟线程由ForkJoinPool调度，该池不支持线程优先级），如果你的任务需要严格的优先级控制（比如实时监控、紧急告警处理），必须使用平台线程，因为平台线程的优先级会被操作系统识别并调度。

示例：高优先级的系统监控任务 #

假设我们需要一个高优先级的监控任务，确保系统负载过高时能立即触发告警，不能被其他低优先级任务抢占CPU：

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // 高优先级平台线程：处理系统监控告警
        Thread highPriorityMonitor = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                double systemLoad = getSystemLoad();
                if (systemLoad > 8.0) {
                    System.err.println("紧急告警：系统负载过高！当前负载：" + systemLoad);
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        // 设置最高优先级
        highPriorityMonitor.setPriority(Thread.MAX_PRIORITY);
        highPriorityMonitor.start();

        // 低优先级平台线程：处理批量日志分析
        Thread lowPriorityLogProcessor = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                processBatchLogs();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        // 设置最低优先级
        lowPriorityLogProcessor.setPriority(Thread.MIN_PRIORITY);
        lowPriorityLogProcessor.start();
    }

    // 模拟获取系统负载
    private static double getSystemLoad() {
        return Math.random() * 10; // 模拟随机负载值
    }

    // 模拟批量日志处理
    private static void processBatchLogs() {
        System.out.println("正在处理批量日志...");
        // 模拟CPU密集型日志处理
        for (int i = 0; i < 1000000; i++) {
            Math.sqrt(i);
        }
    }
}

原因分析：平台线程的优先级会被操作系统认可，当系统负载过高时，高优先级的监控线程能优先获取CPU时间，及时触发告警；而如果改用虚拟线程，设置的优先级不会生效，监控任务可能被其他低优先级的虚拟线程抢占，导致告警延迟。

内容的提问来源于stack exchange，提问作者xtay2