登录 注册

Java 17新特性深度解析：虚拟线程与结构化并发在高并发系统中的应用

DeepMusic
DeepMusic 2026-02-05T05:08:09+08:00
0 0 0

引言

Java 17作为Oracle发布的长期支持（LTS）版本，带来了许多重要的新特性和改进。其中，虚拟线程（Virtual Threads）和结构化并发模型的引入，标志着Java并发编程进入了一个全新的时代。这些特性不仅解决了传统线程模型在高并发场景下的性能瓶颈，还为开发者提供了更加简洁、高效的并发编程方式。

本文将深入解析Java 17中的虚拟线程和结构化并发特性，探讨它们如何提升高并发系统的性能，并提供实际的代码示例和性能测试结果，帮助读者更好地理解和应用这些新特性。

Java 17核心新特性概述

虚拟线程（Virtual Threads）

虚拟线程是Java 17中最重要的新特性之一。它是一种轻量级的线程实现，旨在解决传统Java线程在高并发场景下的性能问题。与传统的平台线程不同，虚拟线程由JVM管理，不需要直接映射到操作系统线程，从而大大减少了线程创建和管理的开销。

结构化并发模型

结构化并发模型是Java 17中另一个重要特性，它提供了一种更加安全和可控的方式来处理并发任务。通过引入StructuredTaskScope类，开发者可以更轻松地管理任务之间的依赖关系，避免了传统并发编程中的各种问题。

虚拟线程详解

虚拟线程的概念与优势

虚拟线程是一种由JVM管理的轻量级线程实现。与传统的平台线程相比，虚拟线程具有以下显著优势：

  1. 低内存开销：每个虚拟线程的初始堆栈大小仅为4KB，而传统线程通常需要1MB
  2. 高并发性：可以轻松创建数万个甚至数十万个线程
  3. 资源效率：避免了平台线程创建和销毁的系统开销
  4. 简化编程：开发者无需关心线程池管理等复杂问题

虚拟线程的创建与使用

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

public class VirtualThreadExample {
    
    public static void main(String[] args) {
        // 创建虚拟线程的方式
        Thread virtualThread = Thread.ofVirtual()
                .name("MyVirtualThread")
                .unstarted(() -> {
                    System.out.println("虚拟线程执行任务");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    System.out.println("虚拟线程任务完成");
                });
        
        virtualThread.start();
        
        // 使用ExecutorService创建虚拟线程池
        var executor = Executors.newVirtualThreadPerTaskExecutor();
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务执行中");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("异步任务完成");
        }, executor);
        
        future.join();
        executor.close();
    }
}

虚拟线程与平台线程的对比

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

public class ThreadComparison {
    
    public static void compareThreadPerformance() {
        int taskCount = 10000;
        
        // 平台线程测试
        long platformStartTime = System.currentTimeMillis();
        ExecutorService platformExecutor = Executors.newFixedThreadPool(100);
        
        for (int i = 0; i < taskCount; i++) {
            final int taskId = i;
            platformExecutor.submit(() -> {
                // 模拟一些工作
                try {
                    Thread.sleep(ThreadLocalRandom.current().nextInt(100));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("平台线程任务 " + taskId + " 完成");
            });
        }
        
        platformExecutor.shutdown();
        long platformEndTime = System.currentTimeMillis();
        
        // 虚拟线程测试
        long virtualStartTime = System.currentTimeMillis();
        ExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();
        
        for (int i = 0; i < taskCount; i++) {
            final int taskId = i;
            virtualExecutor.submit(() -> {
                // 模拟一些工作
                try {
                    Thread.sleep(ThreadLocalRandom.current().nextInt(100));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("虚拟线程任务 " + taskId + " 完成");
            });
        }
        
        virtualExecutor.shutdown();
        long virtualEndTime = System.currentTimeMillis();
        
        System.out.println("平台线程执行时间: " + (platformEndTime - platformStartTime) + "ms");
        System.out.println("虚拟线程执行时间: " + (virtualEndTime - virtualStartTime) + "ms");
    }
}

结构化并发模型深入解析

StructuredTaskScope基础概念

结构化并发模型通过StructuredTaskScope类提供了一种更加安全的并发任务管理方式。它确保了任务的生命周期是结构化的，避免了传统并发编程中的各种问题。

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.CompletableFuture;

public class StructuredConcurrencyExample {
    
    public static void demonstrateStructuredConcurrency() {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            // 启动多个任务
            CompletableFuture<String> task1 = scope.fork(() -> {
                Thread.sleep(1000);
                return "Task 1 Result";
            });
            
            CompletableFuture<String> task2 = scope.fork(() -> {
                Thread.sleep(1500);
                return "Task 2 Result";
            });
            
            CompletableFuture<String> task3 = scope.fork(() -> {
                Thread.sleep(800);
                return "Task 3 Result";
            });
            
            // 等待所有任务完成
            scope.join();
            
            // 获取结果
            String result1 = task1.getNow("Default");
            String result2 = task2.getNow("Default");
            String result3 = task3.getNow("Default");
            
            System.out.println("Task 1: " + result1);
            System.out.println("Task 2: " + result2);
            System.out.println("Task 3: " + result3);
            
        } catch (Exception e) {
            System.err.println("并发任务执行失败: " + e.getMessage());
        }
    }
    
    public static void demonstrateStructuredConcurrencyWithFailure() {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            // 启动一个会失败的任务
            CompletableFuture<String> failingTask = scope.fork(() -> {
                throw new RuntimeException("任务执行失败");
            });
            
            // 启动正常任务
            CompletableFuture<String> normalTask = scope.fork(() -> {
                Thread.sleep(1000);
                return "正常任务结果";
            });
            
            scope.join();
            
        } catch (Exception e) {
            System.err.println("结构化并发执行失败: " + e.getMessage());
        }
    }
}

高级结构化并发模式

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.CompletableFuture;
import java.util.List;
import java.util.ArrayList;

public class AdvancedStructuredConcurrency {
    
    // 批量任务处理
    public static List<String> processBatchTasks(List<String> tasks) {
        var results = new ArrayList<String>();
        
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            List<CompletableFuture<String>> futures = new ArrayList<>();
            
            for (String task : tasks) {
                CompletableFuture<String> future = scope.fork(() -> {
                    // 模拟任务处理
                    Thread.sleep(100);
                    return "处理完成: " + task;
                });
                futures.add(future);
            }
            
            scope.join();
            
            for (CompletableFuture<String> future : futures) {
                results.add(future.getNow("默认结果"));
            }
            
        } catch (Exception e) {
            System.err.println("批量任务处理失败: " + e.getMessage());
        }
        
        return results;
    }
    
    // 依赖任务执行
    public static String executeDependentTasks(String input) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            // 第一步：数据准备
            CompletableFuture<String> preparationTask = scope.fork(() -> {
                Thread.sleep(500);
                return "数据准备完成: " + input;
            });
            
            // 第二步：数据处理
            CompletableFuture<String> processingTask = scope.fork(() -> {
                String preparedData = preparationTask.getNow("默认数据");
                Thread.sleep(800);
                return "数据处理完成: " + preparedData;
            });
            
            // 第三步：结果验证
            CompletableFuture<String> validationTask = scope.fork(() -> {
                String processedData = processingTask.getNow("默认处理结果");
                Thread.sleep(300);
                return "验证通过: " + processedData;
            });
            
            scope.join();
            
            return validationTask.getNow("默认结果");
            
        } catch (Exception e) {
            System.err.println("依赖任务执行失败: " + e.getMessage());
            return "执行失败";
        }
    }
}

高并发系统中的实际应用

Web服务高并发处理

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

public class HighConcurrencyWebServer {
    
    // 模拟Web请求处理
    public static void handleHttpRequest(String requestId) {
        try {
            // 模拟网络延迟和数据库查询
            Thread.sleep(ThreadLocalRandom.current().nextInt(100, 500));
            
            System.out.println("请求 " + requestId + " 处理完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    // 使用虚拟线程处理高并发请求
    public static void handleHighConcurrencyRequests(int requestCount) {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < requestCount; i++) {
            final int requestId = i;
            executor.submit(() -> handleHttpRequest("REQ-" + requestId));
        }
        
        executor.close();
        long endTime = System.currentTimeMillis();
        
        System.out.println("处理 " + requestCount + " 个请求耗时: " + 
                          (endTime - startTime) + "ms");
    }
    
    // 异步处理方式
    public static CompletableFuture<Void> asyncHandleRequest(String requestId) {
        return CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(100, 500));
                System.out.println("异步请求 " + requestId + " 处理完成");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
    
    public static void handleRequestsAsync(int requestCount) {
        long startTime = System.currentTimeMillis();
        
        CompletableFuture<?>[] futures = new CompletableFuture[requestCount];
        for (int i = 0; i < requestCount; i++) {
            final int requestId = i;
            futures[i] = asyncHandleRequest("ASYNC-REQ-" + requestId);
        }
        
        CompletableFuture.allOf(futures).join();
        
        long endTime = System.currentTimeMillis();
        System.out.println("异步处理 " + requestCount + " 个请求耗时: " + 
                          (endTime - startTime) + "ms");
    }
}

数据库连接池优化

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DatabaseConnectionOptimization {
    
    // 传统数据库操作
    public static void traditionalDatabaseOperation(String query) {
        try {
            Connection conn = DriverManager.getConnection(
                "jdbc:derby:memory:testdb", "user", "password");
            
            // 模拟数据库查询
            Thread.sleep(100);
            System.out.println("传统方式执行查询: " + query);
            
            conn.close();
        } catch (SQLException | InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    // 使用虚拟线程优化数据库操作
    public static void optimizedDatabaseOperation(String query) {
        try {
            // 使用虚拟线程执行数据库操作
            CompletableFuture.runAsync(() -> {
                try {
                    Connection conn = DriverManager.getConnection(
                        "jdbc:derby:memory:testdb", "user", "password");
                    
                    // 模拟数据库查询
                    Thread.sleep(100);
                    System.out.println("优化方式执行查询: " + query);
                    
                    conn.close();
                } catch (SQLException | InterruptedException e) {
                    e.printStackTrace();
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    // 批量数据库操作
    public static void batchDatabaseOperations(int operationCount) {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < operationCount; i++) {
            final int operationId = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(50);
                    System.out.println("批量操作 " + operationId + " 完成");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        executor.close();
        long endTime = System.currentTimeMillis();
        
        System.out.println("批量处理 " + operationCount + " 个数据库操作耗时: " + 
                          (endTime - startTime) + "ms");
    }
}

性能测试与对比分析

基准性能测试

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

public class PerformanceBenchmark {
    
    private static final int THREAD_COUNT = 10000;
    private static final int ITERATIONS = 1000;
    
    public static void benchmarkPlatformThreads() throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(100);
        AtomicInteger completedTasks = new AtomicInteger(0);
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int taskId = i;
            executor.submit(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    // 模拟工作负载
                    Thread.yield();
                }
                completedTasks.incrementAndGet();
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
        long endTime = System.currentTimeMillis();
        
        System.out.println("平台线程基准测试:");
        System.out.println("任务数: " + THREAD_COUNT);
        System.out.println("迭代次数: " + ITERATIONS);
        System.out.println("总耗时: " + (endTime - startTime) + "ms");
        System.out.println("完成任务数: " + completedTasks.get());
    }
    
    public static void benchmarkVirtualThreads() throws InterruptedException {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        AtomicInteger completedTasks = new AtomicInteger(0);
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int taskId = i;
            executor.submit(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    // 模拟工作负载
                    Thread.yield();
                }
                completedTasks.incrementAndGet();
            });
        }
        
        executor.close();
        long endTime = System.currentTimeMillis();
        
        System.out.println("虚拟线程基准测试:");
        System.out.println("任务数: " + THREAD_COUNT);
        System.out.println("迭代次数: " + ITERATIONS);
        System.out.println("总耗时: " + (endTime - startTime) + "ms");
        System.out.println("完成任务数: " + completedTasks.get());
    }
    
    public static void main(String[] args) {
        try {
            benchmarkPlatformThreads();
            System.out.println();
            benchmarkVirtualThreads();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

内存使用对比测试

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MemoryUsageComparison {
    
    public static void printMemoryUsage(String label) {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        
        System.out.println(label + ":");
        System.out.println("  已使用: " + formatBytes(heapUsage.getUsed()));
        System.out.println("  最大可用: " + formatBytes(heapUsage.getMax()));
        System.out.println("  当前堆大小: " + formatBytes(heapUsage.getCommitted()));
    }
    
    private static String formatBytes(long bytes) {
        if (bytes < 1024) return bytes + " B";
        int exp = (int) (Math.log(bytes) / Math.log(1024));
        char pre = ("KMGTPE").charAt(exp - 1);
        return String.format("%.1f %sB", bytes / Math.pow(1024, exp), pre);
    }
    
    public static void memoryTestWithPlatformThreads() {
        printMemoryUsage("平台线程测试开始");
        
        ExecutorService executor = Executors.newFixedThreadPool(1000);
        
        for (int i = 0; i < 5000; i++) {
            final int taskId = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        executor.shutdown();
        try {
            executor.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        printMemoryUsage("平台线程测试结束");
    }
    
    public static void memoryTestWithVirtualThreads() {
        printMemoryUsage("虚拟线程测试开始");
        
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        for (int i = 0; i < 5000; i++) {
            final int taskId = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        executor.close();
        
        printMemoryUsage("虚拟线程测试结束");
    }
    
    public static void main(String[] args) {
        memoryTestWithPlatformThreads();
        System.out.println();
        memoryTestWithVirtualThreads();
    }
}

最佳实践与注意事项

虚拟线程使用最佳实践

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

public class VirtualThreadBestPractices {
    
    // 1. 合理使用虚拟线程池
    public static void properVirtualThreadPoolUsage() {
        // 使用newVirtualThreadPerTaskExecutor()创建线程池
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            
            // 执行任务
            for (int i = 0; i < 1000; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    // 执行业务逻辑
                    performBusinessLogic(taskId);
                });
            }
        } catch (Exception e) {
            System.err.println("任务执行失败: " + e.getMessage());
        }
    }
    
    private static void performBusinessLogic(int taskId) {
        try {
            // 模拟业务处理
            Thread.sleep(ThreadLocalRandom.current().nextInt(100, 500));
            System.out.println("任务 " + taskId + " 处理完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    // 2. 避免长时间阻塞
    public static void avoidLongBlocking() {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            
            // 建议使用异步方式避免阻塞
            CompletableFuture.runAsync(() -> {
                // 使用CompletableFuture而不是直接sleep
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }, executor);
            
        } catch (Exception e) {
            System.err.println("异步任务执行失败: " + e.getMessage());
        }
    }
    
    // 3. 合理管理资源
    public static void resourceManagement() {
        // 使用try-with-resources确保资源正确释放
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // 执行大量任务
            for (int i = 0; i < 10000; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    // 处理任务
                    processTask(taskId);
                });
            }
        } catch (Exception e) {
            System.err.println("资源管理失败: " + e.getMessage());
        }
    }
    
    private static void processTask(int taskId) {
        // 任务处理逻辑
        System.out.println("处理任务: " + taskId);
    }
}

结构化并发最佳实践

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.CompletableFuture;
import java.util.List;
import java.util.ArrayList;

public class StructuredConcurrencyBestPractices {
    
    // 1. 使用结构化并发处理依赖任务
    public static String processDependentTasks() {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            // 创建依赖任务
            CompletableFuture<String> task1 = scope.fork(() -> {
                Thread.sleep(500);
                return "数据准备完成";
            });
            
            CompletableFuture<String> task2 = scope.fork(() -> {
                String data = task1.getNow("默认数据");
                Thread.sleep(800);
                return "数据处理完成: " + data;
            });
            
            scope.join();
            
            return task2.getNow("默认结果");
            
        } catch (Exception e) {
            System.err.println("任务执行失败: " + e.getMessage());
            return "执行失败";
        }
    }
    
    // 2. 批量处理任务
    public static List<String> batchProcess(List<String> inputs) {
        var results = new ArrayList<String>();
        
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            List<CompletableFuture<String>> futures = new ArrayList<>();
            
            for (String input : inputs) {
                CompletableFuture<String> future = scope.fork(() -> {
                    // 模拟处理
                    Thread.sleep(100);
                    return "处理结果: " + input;
                });
                futures.add(future);
            }
            
            scope.join();
            
            for (CompletableFuture<String> future : futures) {
                results.add(future.getNow("默认结果"));
            }
            
        } catch (Exception e) {
            System.err.println("批量处理失败: " + e.getMessage());
        }
        
        return results;
    }
    
    // 3. 异常处理最佳实践
    public static String handleExceptionsGracefully() {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            CompletableFuture<String> task1 = scope.fork(() -> {
                Thread.sleep(500);
                return "正常任务结果";
            });
            
            CompletableFuture<String> task2 = scope.fork(() -> {
                throw new RuntimeException("模拟异常");
            });
            
            scope.join();
            
            return task1.getNow("默认结果");
            
        } catch (Exception e) {
            System.err.println("结构化并发异常处理: " + e.getMessage());
            return "异常处理结果";
        }
    }
}

性能优化建议

线程池配置优化

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

public class ThreadPoolOptimization {
    
    // 根据不同场景选择合适的线程池
    public static void optimizeThreadPoolConfiguration() {
        // 1. CPU密集型任务 - 使用固定大小线程池
        ExecutorService cpuIntensiveExecutor = 
            Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        
        // 2. I/O密集型任务 - 使用虚拟线程
        ExecutorService ioIntensiveExecutor = 
            Executors.newVirtualThreadPerTaskExecutor();
        
        // 3. 混合负载 - 动态调整
        ExecutorService dynamicExecutor = createDynamicThreadPool();
        
        // 执行任务
        executeTasks(cpuIntensiveExecutor, ioIntensiveExecutor, dynamicExecutor);
    }
    
    private static ExecutorService createDynamicThreadPool() {
        // 可以根据系统负载动态调整
        return Executors.newVirtualThreadPerTaskExecutor();
    }
    
    private static void executeTasks(ExecutorService cpuExecutor, 
                                   ExecutorService ioExecutor,
                                   ExecutorService dynamicExecutor) {
        // CPU密集型任务
        for (int i = 0; i < 100; i++) {
            cpuExecutor.submit(() -> {
                // CPU计算密集型任务
                long sum = 0;
                for (int j = 0; j < 1000000; j++) {
                    sum += j;
                }
            });
        }
        
        // I/O密集型任务
        for (int i = 0; i < 1000; i++) {
            ioExecutor.submit(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        // 动态任务
        for (int i = 0; i < 500; i++) {
            dynamicExecutor.submit(() -> {
                // 根据任务特性选择处理方式
                if (isCpuIntensive()) {
                    performCpuTask();
                } else {
                    performIoTask();
                }
            });
        }
    }
    
    private static boolean isCpuIntensive() {
        return Math.random() > 0.5;
    }
    
    private static void performCpuTask() {
        long sum = 0;
        for (int i = 0; i < 100000; i++) {
            sum += i;
        }
    }
    
    private static void performIoTask() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

监控与调优

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;

public class PerformanceMonitoring {
    
    private static final AtomicLong taskCount = new AtomicLong(0);
    private static final AtomicLong executionTime = new AtomicLong(0);
    
    // 性能监控工具
    public static void monitorPerformance() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        
        // 获取线程信息
        int threadCount = threadBean.getThreadCount
# JAVA # 虚拟线程 # 17
相关推荐
广告位招租

相似文章

    评论 (0)

    0/2000