Java 17新特性实战：虚拟线程与并发编程的革命性变化

引言

Java 17作为Oracle发布的长期支持版本，带来了许多重要的新特性，其中最引人注目的当属虚拟线程（Virtual Threads）的引入。虚拟线程是Java并发编程领域的一次重大革新，它彻底改变了我们编写高并发应用程序的方式。本文将深入剖析Java 17中虚拟线程的特性和使用方法，并通过实际案例展示如何利用虚拟线程提高并发程序的性能和可扩展性。

虚拟线程概述

什么是虚拟线程？

虚拟线程（Virtual Thread）是Java 17中引入的一种轻量级线程实现。与传统的平台线程（Platform Thread）相比，虚拟线程具有以下显著特点：

• 极低的内存开销：每个虚拟线程仅占用约1KB的堆内存
• 高效的调度机制：由JVM内部的线程调度器管理，无需操作系统级别的线程切换
• 更好的可扩展性：可以轻松创建数万个甚至数十万个线程而不会出现性能问题
• 透明的API使用：虚拟线程的API与传统线程完全兼容

虚拟线程与平台线程的区别

虚拟线程的使用方法

基本创建方式

在Java 17中，可以通过以下几种方式创建虚拟线程：

// 方式1：使用Thread.ofVirtual()构建器
Thread virtualThread = Thread.ofVirtual()
    .name("MyVirtualThread")
    .unstarted(() -> {
        System.out.println("Hello from virtual thread: " + Thread.currentThread().getName());
    });

// 方式2：直接启动虚拟线程
Thread virtualThread2 = Thread.ofVirtual()
    .start(() -> {
        System.out.println("Hello from virtual thread 2: " + Thread.currentThread().getName());
    });

// 方式3：使用Thread构造函数（需要JDK 17+）
Thread virtualThread3 = new Thread(Thread.ofVirtual(), () -> {
    System.out.println("Hello from virtual thread 3: " + Thread.currentThread().getName());
});

虚拟线程的生命周期管理

虚拟线程的生命周期管理与传统线程类似，但具有一些特殊特性：

public class VirtualThreadLifecycle {
    public static void main(String[] args) throws InterruptedException {
        // 创建并启动虚拟线程
        Thread virtualThread = Thread.ofVirtual()
            .name("LifecycleThread")
            .start(() -> {
                try {
                    System.out.println("Thread started: " + Thread.currentThread().getName());
                    
                    // 模拟一些工作
                    Thread.sleep(1000);
                    
                    System.out.println("Thread working...");
                    
                    // 模拟异常处理
                    if (Math.random() > 0.5) {
                        throw new RuntimeException("Simulated error");
                    }
                    
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Thread interrupted");
                } catch (Exception e) {
                    System.out.println("Exception occurred: " + e.getMessage());
                } finally {
                    System.out.println("Thread finished: " + Thread.currentThread().getName());
                }
            });
        
        // 等待线程完成
        virtualThread.join();
        System.out.println("Main thread completed");
    }
}

实际应用案例

1. 高并发Web服务处理

让我们通过一个实际的Web服务场景来展示虚拟线程的优势：

import java.net.http.*;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class WebServiceExample {
    
    private static final HttpClient httpClient = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(5))
        .build();
    
    // 使用传统平台线程处理高并发请求
    public static void processWithPlatformThreads(int requestCount) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(100);
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < requestCount; i++) {
            final int requestId = i;
            executor.submit(() -> {
                try {
                    HttpRequest request = HttpRequest.newBuilder()
                        .uri(java.net.URI.create("https://httpbin.org/delay/1"))
                        .timeout(Duration.ofSeconds(10))
                        .GET()
                        .build();
                    
                    HttpResponse<String> response = httpClient.send(request, 
                        HttpResponse.BodyHandlers.ofString());
                    
                    System.out.println("Request " + requestId + " completed with status: " + 
                        response.statusCode());
                } catch (Exception e) {
                    System.err.println("Request " + requestId + " failed: " + e.getMessage());
                }
            });
        }
        
        executor.shutdown();
        while (!executor.isTerminated()) {
            Thread.sleep(100);
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("Platform threads approach took: " + (endTime - startTime) + "ms");
    }
    
    // 使用虚拟线程处理高并发请求
    public static void processWithVirtualThreads(int requestCount) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        
        Thread[] threads = new Thread[requestCount];
        
        for (int i = 0; i < requestCount; i++) {
            final int requestId = i;
            threads[i] = Thread.ofVirtual()
                .name("VirtualThread-" + requestId)
                .start(() -> {
                    try {
                        HttpRequest request = HttpRequest.newBuilder()
                            .uri(java.net.URI.create("https://httpbin.org/delay/1"))
                            .timeout(Duration.ofSeconds(10))
                            .GET()
                            .build();
                        
                        HttpResponse<String> response = httpClient.send(request, 
                            HttpResponse.BodyHandlers.ofString());
                        
                        System.out.println("Request " + requestId + " completed with status: " + 
                            response.statusCode());
                    } catch (Exception e) {
                        System.err.println("Request " + requestId + " failed: " + e.getMessage());
                    }
                });
        }
        
        // 等待所有虚拟线程完成
        for (Thread thread : threads) {
            thread.join();
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("Virtual threads approach took: " + (endTime - startTime) + "ms");
    }
    
    public static void main(String[] args) throws InterruptedException {
        int requestCount = 100;
        
        System.out.println("=== Testing with Platform Threads ===");
        processWithPlatformThreads(requestCount);
        
        System.out.println("\n=== Testing with Virtual Threads ===");
        processWithVirtualThreads(requestCount);
    }
}

2. 数据处理管道

虚拟线程在数据处理管道中也能发挥巨大优势：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;

public class DataProcessingPipeline {
    
    // 模拟数据处理任务
    private static String processTask(String data) {
        try {
            // 模拟CPU密集型任务
            Thread.sleep(10);
            return data.toUpperCase() + "-PROCESSED";
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return "ERROR";
        }
    }
    
    // 使用传统线程池处理
    public static void processWithThreadPool(int taskCount) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        long startTime = System.currentTimeMillis();
        
        CompletableFuture<?>[] futures = new CompletableFuture[taskCount];
        
        for (int i = 0; i < taskCount; i++) {
            final int taskId = i;
            futures[i] = CompletableFuture.runAsync(() -> {
                String result = processTask("data-" + taskId);
                System.out.println("Task " + taskId + " completed: " + result);
            }, executor);
        }
        
        CompletableFuture.allOf(futures).join();
        long endTime = System.currentTimeMillis();
        System.out.println("ThreadPool approach took: " + (endTime - startTime) + "ms");
        
        executor.shutdown();
    }
    
    // 使用虚拟线程处理
    public static void processWithVirtualThreads(int taskCount) {
        long startTime = System.currentTimeMillis();
        
        Thread[] threads = new Thread[taskCount];
        
        for (int i = 0; i < taskCount; i++) {
            final int taskId = i;
            threads[i] = Thread.ofVirtual()
                .name("Processor-" + taskId)
                .start(() -> {
                    String result = processTask("data-" + taskId);
                    System.out.println("Task " + taskId + " completed: " + result);
                });
        }
        
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("Virtual threads approach took: " + (endTime - startTime) + "ms");
    }
    
    public static void main(String[] args) {
        int taskCount = 1000;
        
        System.out.println("=== Processing " + taskCount + " tasks ===");
        
        System.out.println("\n--- Using ThreadPool ---");
        processWithThreadPool(taskCount);
        
        System.out.println("\n--- Using Virtual Threads ---");
        processWithVirtualThreads(taskCount);
    }
}

3. 异步编程与CompletableFuture

虚拟线程与CompletableFuture的结合使用可以实现更优雅的异步编程：

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

public class AsyncProgrammingExample {
    
    // 模拟异步任务
    private static CompletableFuture<String> asyncTask(String name, int delay) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(delay);
                return name + " completed after " + delay + "ms";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return name + " interrupted";
            }
        });
    }
    
    // 使用传统线程池
    public static void asyncWithThreadPool() {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        long startTime = System.currentTimeMillis();
        
        CompletableFuture<?>[] futures = new CompletableFuture[20];
        
        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            futures[i] = asyncTask("Task-" + taskId, 100)
                .thenAccept(result -> System.out.println(result));
        }
        
        CompletableFuture.allOf(futures).join();
        long endTime = System.currentTimeMillis();
        System.out.println("ThreadPool approach took: " + (endTime - startTime) + "ms");
        
        executor.shutdown();
    }
    
    // 使用虚拟线程
    public static void asyncWithVirtualThreads() {
        long startTime = System.currentTimeMillis();
        
        Thread[] threads = new Thread[20];
        
        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            threads[i] = Thread.ofVirtual()
                .name("AsyncTask-" + taskId)
                .start(() -> {
                    asyncTask("Task-" + taskId, 100)
                        .thenAccept(result -> System.out.println(result))
                        .join(); // 等待完成
                });
        }
        
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("Virtual threads approach took: " + (endTime - startTime) + "ms");
    }
    
    // 混合使用虚拟线程和传统线程
    public static void mixedApproach() {
        // 使用虚拟线程处理I/O密集型任务
        CompletableFuture<?>[] virtualFutures = new CompletableFuture[10];
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            virtualFutures[i] = CompletableFuture.supplyAsync(() -> {
                try {
                    Thread.sleep(50);
                    return "Virtual Task-" + taskId + " completed";
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return "Virtual Task-" + taskId + " interrupted";
                }
            }, 
            // 使用虚拟线程执行器
            CompletableFuture.delayedExecutor(0, java.util.concurrent.TimeUnit.MILLISECONDS));
        }
        
        // 使用传统线程池处理CPU密集型任务
        ExecutorService cpuExecutor = Executors.newFixedThreadPool(4);
        CompletableFuture<?>[] cpuFutures = new CompletableFuture[5];
        
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            cpuFutures[i] = CompletableFuture.runAsync(() -> {
                // 模拟CPU密集型计算
                long sum = 0;
                for (long j = 0; j < 1000000; j++) {
                    sum += j;
                }
                System.out.println("CPU Task-" + taskId + " completed with sum: " + sum);
            }, cpuExecutor);
        }
        
        CompletableFuture.allOf(virtualFutures).join();
        CompletableFuture.allOf(cpuFutures).join();
        
        long endTime = System.currentTimeMillis();
        System.out.println("Mixed approach took: " + (endTime - startTime) + "ms");
        
        cpuExecutor.shutdown();
    }
    
    public static void main(String[] args) {
        System.out.println("=== Async Programming Examples ===");
        
        System.out.println("\n--- Using ThreadPool ---");
        asyncWithThreadPool();
        
        System.out.println("\n--- Using Virtual Threads ---");
        asyncWithVirtualThreads();
        
        System.out.println("\n--- Mixed Approach ---");
        mixedApproach();
    }
}

性能优化最佳实践

1. 线程池配置优化

虽然虚拟线程可以处理大量并发任务，但在某些场景下合理配置线程池仍然重要：

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

public class ThreadPoolsOptimization {
    
    // 为不同类型的任务选择合适的执行器
    public static void optimizedTaskExecution() {
        // 1. I/O密集型任务 - 使用虚拟线程
        ExecutorService ioExecutor = Executors.newVirtualThreadPerTaskExecutor();
        
        // 2. CPU密集型任务 - 使用固定大小的平台线程池
        ExecutorService cpuExecutor = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors());
        
        // 3. 混合任务 - 使用信号量控制并发度
        Semaphore semaphore = new Semaphore(100); // 限制同时执行的任务数
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < 1000; i++) {
            final int taskId = i;
            
            if (taskId % 3 == 0) {
                // I/O密集型任务
                ioExecutor.submit(() -> {
                    try {
                        Thread.sleep(100);
                        System.out.println("IO Task " + taskId + " completed");
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
            } else if (taskId % 3 == 1) {
                // CPU密集型任务
                cpuExecutor.submit(() -> {
                    long sum = 0;
                    for (long j = 0; j < 1000000; j++) {
                        sum += j;
                    }
                    System.out.println("CPU Task " + taskId + " completed with sum: " + sum);
                });
            } else {
                // 混合任务
                ioExecutor.submit(() -> {
                    try {
                        semaphore.acquire();
                        Thread.sleep(50);
                        System.out.println("Mixed Task " + taskId + " completed");
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } finally {
                        semaphore.release();
                    }
                });
            }
        }
        
        // 关闭执行器
        ioExecutor.shutdown();
        cpuExecutor.shutdown();
        
        long endTime = System.currentTimeMillis();
        System.out.println("Optimized approach took: " + (endTime - startTime) + "ms");
    }
    
    public static void main(String[] args) {
        optimizedTaskExecution();
    }
}

2. 内存管理与资源回收

虚拟线程虽然轻量，但仍需注意内存管理和资源回收：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicInteger;

public class MemoryManagementExample {
    
    private static final AtomicInteger threadCounter = new AtomicInteger(0);
    
    // 监控虚拟线程的创建和销毁
    public static void monitorVirtualThreads() {
        long startTime = System.currentTimeMillis();
        
        // 创建大量虚拟线程
        int threadCount = 10000;
        CompletableFuture<?>[] futures = new CompletableFuture[threadCount];
        
        for (int i = 0; i < threadCount; i++) {
            final int taskId = i;
            futures[i] = CompletableFuture.runAsync(() -> {
                try {
                    // 模拟工作
                    Thread.sleep(10);
                    
                    // 记录线程创建计数
                    int currentCount = threadCounter.incrementAndGet();
                    if (currentCount % 1000 == 0) {
                        System.out.println("Processed " + currentCount + " tasks");
                    }
                    
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        CompletableFuture.allOf(futures).join();
        
        long endTime = System.currentTimeMillis();
        System.out.println("Completed " + threadCount + " tasks in " + (endTime - startTime) + "ms");
        System.out.println("Final thread count: " + threadCounter.get());
    }
    
    // 资源清理示例
    public static void resourceCleanup() {
        // 使用try-with-resources模式管理资源
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            CompletableFuture<?>[] futures = new CompletableFuture[100];
            
            for (int i = 0; i < 100; i++) {
                final int taskId = i;
                futures[i] = CompletableFuture.runAsync(() -> {
                    System.out.println("Task " + taskId + " running on: " + 
                        Thread.currentThread().getName());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }, executor);
            }
            
            CompletableFuture.allOf(futures).join();
        } // 自动关闭executor
    }
    
    public static void main(String[] args) {
        System.out.println("=== Memory Management Example ===");
        monitorVirtualThreads();
        
        System.out.println("\n=== Resource Cleanup Example ===");
        resourceCleanup();
    }
}

3. 异常处理与调试

虚拟线程的异常处理需要特别注意：

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

public class ExceptionHandlingExample {
    
    // 异常处理策略
    public static void exceptionHandlingWithVirtualThreads() {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            
            CompletableFuture.runAsync(() -> {
                try {
                    if (taskId % 3 == 0) {
                        throw new RuntimeException("Simulated error in task " + taskId);
                    }
                    
                    Thread.sleep(100);
                    System.out.println("Task " + taskId + " completed successfully");
                    
                } catch (Exception e) {
                    // 在虚拟线程中处理异常
                    System.err.println("Error in task " + taskId + ": " + e.getMessage());
                    e.printStackTrace();
                    
                    // 可以选择重新抛出或记录日志
                    Thread.currentThread().interrupt();
                }
            }, executor);
        }
        
        executor.shutdown();
    }
    
    // 使用自定义异常处理器
    public static void customExceptionHandler() {
        Thread.UncaughtExceptionHandler handler = (thread, exception) -> {
            System.err.println("Uncaught exception in thread " + thread.getName());
            System.err.println("Exception: " + exception.getMessage());
            exception.printStackTrace();
        };
        
        Thread virtualThread = Thread.ofVirtual()
            .name("CustomHandlerThread")
            .unstarted(() -> {
                Thread.currentThread().setUncaughtExceptionHandler(handler);
                
                // 模拟异常
                throw new RuntimeException("Custom exception from virtual thread");
            });
        
        virtualThread.start();
        
        try {
            virtualThread.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    public static void main(String[] args) {
        System.out.println("=== Exception Handling Examples ===");
        
        System.out.println("\n--- Basic Exception Handling ---");
        exceptionHandlingWithVirtualThreads();
        
        System.out.println("\n--- Custom Exception Handler ---");
        customExceptionHandler();
    }
}

性能对比分析

1. 创建性能测试

public class PerformanceComparison {
    
    public static void testThreadCreationPerformance() {
        int threadCount = 10000;
        
        // 测试平台线程创建性能
        long platformStart = System.currentTimeMillis();
        Thread[] platformThreads = new Thread[threadCount];
        
        for (int i = 0; i < threadCount; i++) {
            platformThreads[i] = new Thread(() -> {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        long platformEnd = System.currentTimeMillis();
        System.out.println("Platform threads creation time: " + (platformEnd - platformStart) + "ms");
        
        // 测试虚拟线程创建性能
        long virtualStart = System.currentTimeMillis();
        Thread[] virtualThreads = new Thread[threadCount];
        
        for (int i = 0; i < threadCount; i++) {
            virtualThreads[i] = Thread.ofVirtual()
                .start(() -> {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
        }
        
        long virtualEnd = System.currentTimeMillis();
        System.out.println("Virtual threads creation time: " + (virtualEnd - virtualStart) + "ms");
        
        // 等待所有线程完成
        for (Thread thread : platformThreads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        for (Thread thread : virtualThreads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    public static void main(String[] args) {
        System.out.println("=== Thread Creation Performance ===");
        testThreadCreationPerformance();
    }
}

2. 内存使用对比

public class MemoryUsageComparison {
    
    public static void measureMemoryUsage() {
        // 模拟大量线程的内存使用情况
        
        System.out.println("=== Memory Usage Analysis ===");
        
        // 创建1000个平台线程（模拟）
        int platformThreadCount = 1000;
        long platformMemoryStart = Runtime.getRuntime().totalMemory() - 
            Runtime.getRuntime().freeMemory();
        
        Thread[] platformThreads = new Thread[platformThreadCount];
        for (int i = 0; i < platformThreadCount; i++) {
            final int id = i;
            platformThreads[i] = new Thread(() -> {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        long platformMemoryEnd = Runtime.getRuntime().totalMemory() - 
            Runtime.getRuntime().freeMemory();
        
        System.out.println("Platform threads memory usage: " + 
            (platformMemoryEnd - platformMemoryStart) / 1024 + " KB");
        
        // 创建1000个虚拟线程（模拟）
        long virtualMemoryStart = Runtime.getRuntime().totalMemory() - 
            Runtime.getRuntime().freeMemory();
        
        Thread[] virtualThreads = new Thread[platformThreadCount];
        for (int i = 0; i < platformThreadCount; i++) {
            final int id = i;
            virtualThreads[i] = Thread.ofVirtual()
                .start(() -> {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
        }
        
        long virtualMemoryEnd = Runtime.getRuntime().totalMemory() - 
            Runtime.getRuntime().freeMemory();
        
        System.out.println("Virtual threads memory usage: " + 
            (virtualMemoryEnd - virtualMemoryStart) / 1024 + " KB");
        
        // 等待完成
        for (Thread thread : platformThreads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        for (Thread thread : virtualThreads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    public static void main(String[] args) {
        measureMemoryUsage();
    }
}

最佳实践总结

1. 适用场景选择

虚拟线程最适合以下场景：

• I/O密集型任务：网络请求、文件读写、数据库操作等
• 高并发处理：需要同时处理大量独立任务的场景
• 微服务架构：在微服务中处理大量异步请求
• Web应用：提高Web应用的并发处理能力

2. 配置建议

public class BestPractices {
    
    // 推荐的虚拟线程使用模式
    public static void recommendedUsage() {
        // 1. 使用newVirtualThreadPerTaskExecutor()创建执行器
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // 2. 为每个任务创建独立的虚拟线程
            CompletableFuture.runAsync(() -> {
                // 执行任务逻辑
                processBusinessLogic();
            }, executor);
        }
        
        // 3. 对于CPU密集型任务，使用传统线程池
        ExecutorService cpuExecutor = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors());
        
        // 4. 合理使用线程池大小和资源管理
        CompletableFuture.runAsync(() -> {
            // CPU密集型任务
            performCpuIntensiveWork();
        }, cpuExecutor);
    }
    
    private static void processBusinessLogic() {
        try {
            // 模拟业务逻辑
            Thread.sleep(100);
            System.out.println("Business logic processed");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    private static void performCpuIntensiveWork() {
        long sum = 0;
        for (long i = 0; i < 1000000; i++) {
            sum += i;
        }
        System.out.println("CPU intensive work completed with sum: " + sum);
    }
    
    public static void main(String[] args) {
        recommendedUsage();
    }
}

3. 监控与调优

import java.lang.management