虚拟线程池 - 技术栈

性能对比示例复制代码

/**
 * 性能对比测试
 */
@Service
public class ThreadPerformanceService {
    
    /**
     * 传统线程池测试
     */
    @Async("taskExecutor")
    public CompletableFuture<String> traditionalAsync(String taskId) {
        // 模拟IO密集型任务（如数据库查询、HTTP请求）
        try {
            Thread.sleep(100); // 模拟100ms的IO等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("传统线程-" + taskId);
    }
    
    /**
     * 虚拟线程测试
     */
    @Async("virtualThreadTaskExecutor")
    public CompletableFuture<String> virtualAsync(String taskId) {
        // 同样的IO密集型任务
        try {
            Thread.sleep(100); // 模拟100ms的IO等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("虚拟线程-" + taskId);
    }
    
    /**
     * 并发测试：1000个任务
     */
    public void performanceTest() {
        long startTime = System.currentTimeMillis();
        
        // 使用传统线程池
        List<CompletableFuture<String>> traditionalTasks = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            traditionalTasks.add(traditionalAsync("task-" + i));
        }
        CompletableFuture.allOf(traditionalTasks.toArray(new CompletableFuture[0])).join();
        
        long traditionalTime = System.currentTimeMillis() - startTime;
        System.out.println("传统线程池耗时: " + traditionalTime + "ms");
        
        // 使用虚拟线程池
        startTime = System.currentTimeMillis();
        List<CompletableFuture<String>> virtualTasks = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            virtualTasks.add(virtualAsync("task-" + i));
        }
        CompletableFuture.allOf(virtualTasks.toArray(new CompletableFuture[0])).join();
        
        long virtualTime = System.currentTimeMillis() - startTime;
        System.out.println("虚拟线程池耗时: " + virtualTime + "ms");
        
        // 结果：虚拟线程池通常比传统线程池快 3-10 倍
    }
}

🏗️ 虚拟线程的工作原理

csharp 复制代码

/**
 * 虚拟线程工作原理演示
 */
public class VirtualThreadDemo {
    
    public static void main(String[] args) {
        // 创建虚拟线程
        Thread virtualThread = Thread.ofVirtual()
                .name("virtual-", 0)
                .start(() -> {
                    System.out.println("虚拟线程名称: " + Thread.currentThread().getName());
                    System.out.println("是否为虚拟线程: " + Thread.currentThread().isVirtual());
                    
                    // 模拟IO操作
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    
                    System.out.println("虚拟线程执行完成");
                });
        
        try {
            virtualThread.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

✅ 非常适合虚拟线程的场景

typescript 复制代码

/**
 * 虚拟线程最佳实践场景
 */
@Service
public class VirtualThreadBestPractices {
    
    /**
     * 1. IO密集型任务 - 数据库查询
     */
    @Async("virtualThreadTaskExecutor")
    public CompletableFuture<List<User>> queryUsersAsync(List<Long> userIds) {
        // 数据库查询是IO密集型，虚拟线程优势明显
        List<User> users = userMapper.selectBatchIds(userIds);
        return CompletableFuture.completedFuture(users);
    }
    
    /**
     * 2. HTTP请求调用
     */
    @Async("virtualThreadTaskExecutor")
    public CompletableFuture<String> callExternalApiAsync(String url) {
        // HTTP请求是IO密集型，虚拟线程可以处理大量并发请求
        RestTemplate restTemplate = new RestTemplate();
        String result = restTemplate.getForObject(url, String.class);
        return CompletableFuture.completedFuture(result);
    }
    
    /**
     * 3. 文件IO操作
     */
    @Async("virtualThreadTaskExecutor")
    public CompletableFuture<String> readFileAsync(String filePath) {
        try {
            String content = Files.readString(Paths.get(filePath));
            return CompletableFuture.completedFuture(content);
        } catch (IOException e) {
            return CompletableFuture.failedFuture(e);
        }
    }
    
    /**
     * 4. 消息队列处理
     */
    @Async("virtualThreadTaskExecutor")
    public CompletableFuture<Void> processMessageAsync(String message) {
        // 消息处理通常涉及IO操作，适合虚拟线程
        messageService.processMessage(message);
        return CompletableFuture.completedFuture(null);
    }
}

❌ 不适合虚拟线程的场景

java 复制代码

/**
 * 不适合虚拟线程的场景
 */
@Service
public class VirtualThreadLimitations {
    
    /**
     * CPU密集型任务 - 不适合虚拟线程
     */
    @Async("taskExecutor") // 使用传统线程池
    public CompletableFuture<BigInteger> calculateFactorialAsync(int n) {
        // CPU密集型计算，传统线程池更合适
        BigInteger result = BigInteger.ONE;
        for (int i = 2; i <= n; i++) {
            result = result.multiply(BigInteger.valueOf(i));
        }
        return CompletableFuture.completedFuture(result);
    }
    
    /**
     * 同步锁竞争 - 不适合虚拟线程
     */
    private final Object lock = new Object();
    
    @Async("taskExecutor") // 使用传统线程池
    public CompletableFuture<String> synchronizedTaskAsync() {
        synchronized (lock) {
            // 同步代码块会阻塞载体线程，影响其他虚拟线程
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return CompletableFuture.completedFuture("完成");
        }
    }
}

🎯 最佳实践建议

typescript 复制代码

/**
 * 虚拟线程使用最佳实践
 */
@Configuration
public class VirtualThreadBestPractices {
    
    /**
     * 1. 混合使用策略
     */
    @Bean("virtualThreadTaskExecutor")
    public VirtualThreadTaskExecutor virtualThreadTaskExecutor() {
        // IO密集型任务使用虚拟线程
        return new VirtualThreadTaskExecutor("io-");
    }
    
    @Bean("cpuThreadTaskExecutor")
    public ThreadPoolTaskExecutor cpuThreadTaskExecutor() {
        // CPU密集型任务使用传统线程池
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors() * 2);
        executor.setThreadNamePrefix("cpu-");
        return executor;
    }
    
    /**
     * 2. 根据任务类型选择执行器
     */
    @Service
    public class TaskService {
        
        // IO密集型任务
        @Async("virtualThreadTaskExecutor")
        public CompletableFuture<String> ioIntensiveTask() {
            // 数据库查询、HTTP请求、文件IO等
            return CompletableFuture.completedFuture("IO任务完成");
        }
        
        // CPU密集型任务
        @Async("cpuThreadTaskExecutor")
        public CompletableFuture<String> cpuIntensiveTask() {
            // 复杂计算、数据处理等
            return CompletableFuture.completedFuture("CPU任务完成");
        }
    }
}