登录 注册

Java 21虚拟线程性能优化深度剖析：从理论到实践的全链路性能提升方案

Heidi260
Heidi260 2026-01-20T21:15:01+08:00
0 0 1

引言

随着现代应用程序对并发处理能力要求的不断提升，传统的Java线程模型在高并发场景下面临着诸多挑战。Java 21引入的虚拟线程（Virtual Threads）作为Project Loom的重要成果，为解决传统线程模型的局限性提供了全新的解决方案。本文将深入剖析Java 21虚拟线程的性能优势、使用场景，并通过实际案例演示如何在高并发场景下利用虚拟线程提升系统吞吐量。

Java 21虚拟线程核心概念与优势

虚拟线程的基本定义

虚拟线程是Java 21中引入的一种新型线程实现方式，它与传统的平台线程（Platform Threads）相比具有显著的性能优势。虚拟线程本质上是一种轻量级的线程抽象，它们由JVM管理而非操作系统直接管理。

// 虚拟线程创建示例
Thread virtualThread = Thread.ofVirtual()
    .name("MyVirtualThread")
    .unstarted(() -> {
        System.out.println("Hello from virtual thread: " + Thread.currentThread());
    });

与平台线程的对比

特性 平台线程 虚拟线程
内存占用 每个线程约1MB栈空间 每个线程约1KB栈空间
上下文切换 频繁，开销大 由JVM管理，开销小
创建成本 高 极低
并发能力 受限于系统资源 可支持百万级并发

虚拟线程在高并发场景中的性能优势

吞吐量提升分析

虚拟线程的引入显著提升了系统的吞吐量。传统平台线程由于创建和管理成本高昂，在高并发场景下容易成为瓶颈。而虚拟线程的轻量化特性使得系统能够轻松处理数万甚至数十万的并发请求。

public class ThroughputComparison {
    private static final int THREAD_COUNT = 10000;
    
    // 使用平台线程的处理方式
    public void platformThreadProcessing() throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(100);
        
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int taskId = i;
            futures.add(CompletableFuture.runAsync(() -> {
                // 模拟业务处理
                processTask(taskId);
            }, executor));
        }
        
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .join();
        executor.shutdown();
    }
    
    // 使用虚拟线程的处理方式
    public void virtualThreadProcessing() throws InterruptedException {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int taskId = i;
            futures.add(CompletableFuture.runAsync(() -> {
                processTask(taskId);
            }, executor));
        }
        
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .join();
        executor.shutdown();
    }
    
    private void processTask(int taskId) {
        // 模拟业务处理
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

内存效率优化

虚拟线程的内存占用远低于平台线程，这使得在高并发场景下能够创建更多的线程而不会导致内存溢出。通过对比测试可以发现，虚拟线程在处理相同任务时，内存使用量减少了90%以上。

public class MemoryEfficiencyTest {
    public static void main(String[] args) throws Exception {
        // 测试平台线程内存占用
        testPlatformThreads();
        
        // 测试虚拟线程内存占用
        testVirtualThreads();
    }
    
    private static void testPlatformThreads() throws InterruptedException {
        System.out.println("Testing platform threads...");
        long startMemory = getUsedMemory();
        
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            Thread thread = new Thread(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            threads.add(thread);
            thread.start();
        }
        
        for (Thread thread : threads) {
            thread.join();
        }
        
        long endMemory = getUsedMemory();
        System.out.println("Platform threads memory usage: " + (endMemory - startMemory) + " KB");
    }
    
    private static void testVirtualThreads() throws InterruptedException {
        System.out.println("Testing virtual threads...");
        long startMemory = getUsedMemory();
        
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            Thread thread = Thread.ofVirtual()
                .unstarted(() -> {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
            threads.add(thread);
            thread.start();
        }
        
        for (Thread thread : threads) {
            thread.join();
        }
        
        long endMemory = getUsedMemory();
        System.out.println("Virtual threads memory usage: " + (endMemory - startMemory) + " KB");
    }
    
    private static long getUsedMemory() {
        Runtime runtime = Runtime.getRuntime();
        return (runtime.totalMemory() - runtime.freeMemory()) / 1024;
    }
}

虚拟线程在实际业务场景中的应用

Web服务高并发处理

在Web服务场景中，虚拟线程能够显著提升请求处理能力。通过将每个HTTP请求分配给一个独立的虚拟线程，可以有效避免传统阻塞式I/O操作导致的性能瓶颈。

@RestController
public class HighConcurrencyController {
    
    // 使用虚拟线程处理高并发请求
    @GetMapping("/high-concurrency")
    public ResponseEntity<String> handleHighConcurrencyRequest() {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        List<CompletableFuture<String>> futures = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            final int taskId = i;
            futures.add(CompletableFuture.supplyAsync(() -> {
                return processBusinessLogic(taskId);
            }, executor));
        }
        
        try {
            List<String> results = futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList());
            
            String response = "Processed " + results.size() + " tasks successfully";
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("Error processing requests: " + e.getMessage());
        }
    }
    
    private String processBusinessLogic(int taskId) {
        // 模拟业务逻辑处理
        try {
            Thread.sleep(10); // 模拟IO等待
            return "Task " + taskId + " completed";
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Interrupted", e);
        }
    }
}

数据库连接池优化

虚拟线程在数据库操作场景中同样表现出色，特别是在需要处理大量并发数据库查询时。通过将每个数据库操作分配给独立的虚拟线程，可以充分利用数据库连接池的资源。

@Service
public class DatabaseService {
    
    @Autowired
    private DataSource dataSource;
    
    // 使用虚拟线程优化数据库操作
    public List<String> batchQueryWithVirtualThreads(List<Integer> userIds) {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        List<CompletableFuture<String>> futures = new ArrayList<>();
        for (Integer userId : userIds) {
            futures.add(CompletableFuture.supplyAsync(() -> {
                return queryUserDetails(userId);
            }, executor));
        }
        
        return futures.stream()
            .map(CompletableFuture::join)
            .collect(Collectors.toList());
    }
    
    private String queryUserDetails(Integer userId) {
        try (Connection conn = dataSource.getConnection();
             PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?")) {
            
            stmt.setInt(1, userId);
            ResultSet rs = stmt.executeQuery();
            
            if (rs.next()) {
                return "User: " + rs.getString("name") + ", Email: " + rs.getString("email");
            }
            return "User not found";
        } catch (SQLException e) {
            throw new RuntimeException("Database query failed", e);
        }
    }
}

线程池配置优化策略

虚拟线程池的最佳实践

在使用虚拟线程时，需要重新审视传统的线程池配置策略。虚拟线程的特性决定了我们不再需要为每个任务创建单独的线程池，而是应该根据具体业务需求进行合理的资源配置。

public class VirtualThreadOptimization {
    
    // 推荐的虚拟线程池配置
    public void recommendedConfigurations() {
        // 1. 每个任务一个虚拟线程（适用于I/O密集型任务）
        ExecutorService executor1 = Executors.newVirtualThreadPerTaskExecutor();
        
        // 2. 固定大小的虚拟线程池（适用于CPU密集型任务）
        ExecutorService executor2 = Thread.ofVirtual()
            .maxPoolSize(100)
            .unstarted(() -> {
                // 业务逻辑
            });
        
        // 3. 自定义虚拟线程池配置
        ExecutorService executor3 = Executors.newThreadPerTaskExecutor(
            Thread.ofVirtual()
                .name("CustomVirtualThread-")
                .daemon(false)
                .unstarted(() -> {})
        );
    }
    
    // 性能测试和调优
    public void performanceTuning() throws InterruptedException {
        int[] threadCounts = {100, 500, 1000, 5000};
        
        for (int threadCount : threadCounts) {
            long startTime = System.currentTimeMillis();
            
            ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
            List<CompletableFuture<Void>> futures = new ArrayList<>();
            
            for (int i = 0; i < threadCount; i++) {
                futures.add(CompletableFuture.runAsync(() -> {
                    // 模拟工作负载
                    doWork();
                }, executor));
            }
            
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .join();
            
            long endTime = System.currentTimeMillis();
            System.out.println("Threads: " + threadCount + 
                ", Time: " + (endTime - startTime) + "ms");
            
            executor.shutdown();
        }
    }
    
    private void doWork() {
        try {
            // 模拟一些工作负载
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

资源监控与调优

合理的资源监控对于虚拟线程的性能优化至关重要。通过监控线程创建、CPU使用率、内存占用等关键指标，可以及时发现并解决潜在的性能问题。

public class ResourceMonitoring {
    
    // 线程池监控工具类
    public static class ThreadMonitor {
        private final ExecutorService executor;
        private final ScheduledExecutorService monitor;
        private final AtomicLong threadCount = new AtomicLong(0);
        
        public ThreadMonitor(ExecutorService executor) {
            this.executor = executor;
            this.monitor = Executors.newScheduledThreadPool(1);
            
            // 定期监控线程状态
            monitor.scheduleAtFixedRate(this::monitorThreadStatus, 0, 5, TimeUnit.SECONDS);
        }
        
        private void monitorThreadStatus() {
            if (executor instanceof ThreadPoolExecutor) {
                ThreadPoolExecutor pool = (ThreadPoolExecutor) executor;
                System.out.println("Active threads: " + pool.getActiveCount());
                System.out.println("Pool size: " + pool.getPoolSize());
                System.out.println("Completed tasks: " + pool.getCompletedTaskCount());
            }
        }
        
        public void shutdown() {
            monitor.shutdown();
            try {
                if (!monitor.awaitTermination(5, TimeUnit.SECONDS)) {
                    monitor.shutdownNow();
                }
            } catch (InterruptedException e) {
                monitor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
    
    // 使用监控工具
    public void useMonitoring() {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        ThreadMonitor monitor = new ThreadMonitor(executor);
        
        // 执行任务
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        // 5秒后关闭监控
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        monitor.shutdown();
    }
}

阻塞操作处理策略

非阻塞编程模式

虚拟线程的核心优势在于能够优雅地处理阻塞操作。通过将阻塞操作封装在适当的异步上下文中，可以最大化利用虚拟线程的并发能力。

public class BlockingOperationHandling {
    
    // 使用CompletableFuture处理阻塞操作
    public CompletableFuture<String> asyncDatabaseQuery(int userId) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟数据库查询
                Thread.sleep(50); // 阻塞操作
                return "User data for ID: " + userId;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
        });
    }
    
    // 复合阻塞操作处理
    public CompletableFuture<String> complexOperation(int userId) {
        return asyncDatabaseQuery(userId)
            .thenCompose(data -> {
                // 第二个异步操作
                return CompletableFuture.supplyAsync(() -> {
                    try {
                        Thread.sleep(30); // 另一个阻塞操作
                        return data + " - Processed";
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeException(e);
                    }
                });
            })
            .thenCompose(result -> {
                // 第三个异步操作
                return CompletableFuture.supplyAsync(() -> {
                    try {
                        Thread.sleep(20); // 最后一个阻塞操作
                        return result + " - Completed";
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeException(e);
                    }
                });
            });
    }
    
    // 使用虚拟线程处理串行阻塞操作
    public void handleSerialBlockingOperations() {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        List<CompletableFuture<String>> futures = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            final int userId = i;
            futures.add(CompletableFuture.supplyAsync(() -> {
                return performBlockingOperation(userId);
            }, executor));
        }
        
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenAccept(results -> {
                System.out.println("All operations completed");
            })
            .join();
    }
    
    private String performBlockingOperation(int userId) {
        try {
            Thread.sleep(100); // 模拟阻塞操作
            return "Result for user " + userId;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

异步编程最佳实践

在使用虚拟线程处理异步任务时，需要遵循一些最佳实践来确保代码的可维护性和性能。

public class AsyncBestPractices {
    
    // 正确的异步编程模式
    public CompletableFuture<String> properAsyncPattern(String input) {
        return CompletableFuture.supplyAsync(() -> {
            // 1. 避免在虚拟线程中进行长时间阻塞操作
            return validateInput(input);
        })
        .thenCompose(validatedInput -> {
            // 2. 使用thenCompose处理异步链式调用
            return processBusinessLogic(validatedInput);
        })
        .thenApply(result -> {
            // 3. 使用thenApply进行结果转换
            return formatResult(result);
        })
        .exceptionally(throwable -> {
            // 4. 合理处理异常
            System.err.println("Error occurred: " + throwable.getMessage());
            return "Default result";
        });
    }
    
    private String validateInput(String input) {
        if (input == null || input.isEmpty()) {
            throw new IllegalArgumentException("Invalid input");
        }
        return input.toUpperCase();
    }
    
    private CompletableFuture<String> processBusinessLogic(String input) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(50); // 模拟业务处理
                return "Processed: " + input;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
        });
    }
    
    private String formatResult(String result) {
        return "[" + result + "]";
    }
    
    // 资源管理最佳实践
    public void resourceManagement() {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        try {
            List<CompletableFuture<String>> futures = new ArrayList<>();
            
            for (int i = 0; i < 100; i++) {
                final int taskId = i;
                CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                    // 使用try-with-resources管理资源
                    try (Resource resource = new Resource()) {
                        return processTask(taskId, resource);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }, executor);
                
                futures.add(future);
            }
            
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .join();
        } finally {
            // 确保executor被正确关闭
            executor.shutdown();
        }
    }
    
    private String processTask(int taskId, Resource resource) throws Exception {
        Thread.sleep(10); // 模拟处理时间
        return "Task " + taskId + " completed";
    }
    
    // 资源类示例
    static class Resource implements AutoCloseable {
        public Resource() {
            System.out.println("Resource acquired");
        }
        
        @Override
        public void close() {
            System.out.println("Resource released");
        }
    }
}

性能监控与指标分析

关键性能指标监控

为了全面评估虚拟线程的性能表现，需要建立一套完善的监控体系，包括CPU使用率、内存占用、线程活跃度等关键指标。

public class PerformanceMonitoring {
    
    // JVM指标收集器
    public static class JvmMetricsCollector {
        private final MeterRegistry meterRegistry;
        
        public JvmMetricsCollector(MeterRegistry meterRegistry) {
            this.meterRegistry = meterRegistry;
            registerJvmMetrics();
        }
        
        private void registerJvmMetrics() {
            // 注册线程相关的指标
            Gauge.builder("jvm.threads.count")
                .description("Current thread count")
                .register(meterRegistry, threadCount -> getThreadCount());
                
            Gauge.builder("jvm.threads.daemon.count")
                .description("Daemon thread count")
                .register(meterRegistry, daemonCount -> getDaemonThreadCount());
                
            Gauge.builder("jvm.memory.used")
                .description("Used memory in bytes")
                .register(meterRegistry, memoryUsed -> getMemoryUsed());
        }
        
        private long getThreadCount() {
            ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
            return threadBean.getThreadCount();
        }
        
        private long getDaemonThreadCount() {
            ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
            return Arrays.stream(threadBean.getThreadInfo(threadBean.getAllThreadIds()))
                .filter(info -> info != null && info.getThreadName().startsWith("VirtualThread"))
                .count();
        }
        
        private long getMemoryUsed() {
            Runtime runtime = Runtime.getRuntime();
            return runtime.totalMemory() - runtime.freeMemory();
        }
    }
    
    // 自定义性能指标
    public static class CustomPerformanceMetrics {
        private final MeterRegistry meterRegistry;
        private final Counter successCounter;
        private final Counter errorCounter;
        private final Timer processingTimer;
        
        public CustomPerformanceMetrics(MeterRegistry meterRegistry) {
            this.meterRegistry = meterRegistry;
            this.successCounter = Counter.builder("app.processing.success")
                .description("Successful processing operations")
                .register(meterRegistry);
                
            this.errorCounter = Counter.builder("app.processing.error")
                .description("Failed processing operations")
                .register(meterRegistry);
                
            this.processingTimer = Timer.builder("app.processing.duration")
                .description("Processing operation duration")
                .register(meterRegistry);
        }
        
        public void recordSuccess() {
            successCounter.increment();
        }
        
        public void recordError() {
            errorCounter.increment();
        }
        
        public Timer.Sample startTimer() {
            return Timer.start(meterRegistry);
        }
    }
}

性能测试框架

构建一个完整的性能测试框架对于验证虚拟线程优化效果至关重要。

public class PerformanceTestingFramework {
    
    // 基准测试类
    public static class BenchmarkRunner {
        private final ExecutorService executor;
        private final int threadCount;
        private final int iterationCount;
        
        public BenchmarkRunner(int threadCount, int iterationCount) {
            this.threadCount = threadCount;
            this.iterationCount = iterationCount;
            this.executor = Executors.newVirtualThreadPerTaskExecutor();
        }
        
        public BenchmarkResult runBenchmark(Runnable task) {
            List<CompletableFuture<Long>> futures = new ArrayList<>();
            
            long startTime = System.nanoTime();
            
            for (int i = 0; i < threadCount; i++) {
                final int taskId = i;
                futures.add(CompletableFuture.supplyAsync(() -> {
                    long taskStart = System.nanoTime();
                    try {
                        for (int j = 0; j < iterationCount; j++) {
                            task.run();
                        }
                        return System.nanoTime() - taskStart;
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }, executor));
            }
            
            long totalTaskTime = futures.stream()
                .mapToLong(future -> {
                    try {
                        return future.get(30, TimeUnit.SECONDS);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                })
                .sum();
            
            long totalTime = System.nanoTime() - startTime;
            
            return new BenchmarkResult(totalTime, totalTaskTime, threadCount);
        }
        
        public void shutdown() {
            executor.shutdown();
        }
    }
    
    // 测试结果类
    public static class BenchmarkResult {
        private final long totalTime;
        private final long totalTaskTime;
        private final int threadCount;
        
        public BenchmarkResult(long totalTime, long totalTaskTime, int threadCount) {
            this.totalTime = totalTime;
            this.totalTaskTime = totalTaskTime;
            this.threadCount = threadCount;
        }
        
        public double getThroughput() {
            return (double) threadCount * iterationCount / (totalTime / 1_000_000_000.0);
        }
        
        public double getEfficiency() {
            return (double) totalTaskTime / totalTime;
        }
        
        @Override
        public String toString() {
            return String.format(
                "BenchmarkResult{totalTime=%dms, throughput=%.2f ops/sec, efficiency=%.2f}",
                totalTime / 1_000_000,
                getThroughput(),
                getEfficiency()
            );
        }
    }
    
    // 实际测试示例
    public void runPerformanceTests() {
        int[] threadCounts = {10, 50, 100, 500};
        int iterations = 1000;
        
        for (int threadCount : threadCounts) {
            BenchmarkRunner runner = new BenchmarkRunner(threadCount, iterations);
            
            Runnable testTask = () -> {
                try {
                    Thread.sleep(1); // 模拟轻量级工作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            };
            
            BenchmarkResult result = runner.runBenchmark(testTask);
            System.out.println("Threads: " + threadCount + ", Result: " + result);
            
            runner.shutdown();
        }
    }
}

实际案例：电商平台高并发处理优化

场景分析

以电商平台的订单处理系统为例，该系统需要同时处理大量用户请求，包括商品查询、下单、支付等操作。传统的平台线程模型在面对高并发场景时容易出现性能瓶颈。

@RestController
@RequestMapping("/order")
public class OrderProcessingController {
    
    private final OrderService orderService;
    private final ExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();
    
    public OrderProcessingController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @PostMapping("/process")
    public ResponseEntity<String> processOrder(@RequestBody OrderRequest request) {
        // 使用虚拟线程处理订单
        CompletableFuture<OrderResult> future = CompletableFuture.supplyAsync(() -> {
            try {
                return orderService.processOrder(request);
            } catch (Exception e) {
                throw new RuntimeException("Order processing failed", e);
            }
        }, virtualExecutor);
        
        try {
            OrderResult result = future.get(30, TimeUnit.SECONDS);
            return ResponseEntity.ok("Order processed successfully: " + result.getOrderId());
        } catch (TimeoutException | InterruptedException | ExecutionException e) {
            return ResponseEntity.status(HttpStatus.REQUEST_TIMEOUT)
                .body("Order processing timed out or failed");
        }
    }
    
    @GetMapping("/batch")
    public ResponseEntity<String> processBatchOrders(@RequestParam int count) {
        List<CompletableFuture<OrderResult>> futures = new ArrayList<>();
        
        for (int i = 0; i < count; i++) {
            final int orderId = i;
            futures.add(CompletableFuture.supplyAsync(() -> {
                try {
                    return orderService.processOrder(createTestOrder(orderId));
                } catch (Exception e) {
                    throw new RuntimeException("Batch order processing failed", e);
                }
            }, virtualExecutor));
        }
        
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenAccept(v -> {
                System.out.println("All " + count + " orders processed");
            })
            .join();
            
        return ResponseEntity.ok("Processed " + count + " orders successfully");
    }
    
    private OrderRequest createTestOrder(int orderId) {
        return new OrderRequest()
            .setOrderId(String.valueOf(orderId))
            .setUserId("user_" + orderId)
            .setItems(Arrays.asList(
                new OrderItem().setProductId("product_" + orderId).setQuantity(1),
                new OrderItem().setProductId("product_" + (orderId + 100)).setQuantity(2)
            ));
    }
}

性能优化前后的对比

通过对比优化前后的性能数据，可以清晰地看到虚拟线程带来的显著提升。

public class PerformanceComparison {
    
    // 模拟优化前的处理方式（使用平台线程）
    public void oldApproach(int taskCount) throws InterruptedException {
        ExecutorService platformExecutor = Executors.newFixedThreadPool(100);
        
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        for (int i = 0; i < taskCount; i++) {
            final int taskId = i;
            futures.add(Comple
# JAVA # 虚拟线程 # 21
相关推荐
广告位招租

相似文章

    评论 (0)

    0/2000