// 創(chuàng)建并啟動(dòng)虛擬線程
Thread virtualThread = Thread.ofVirtual()
    .name("virtual-thread-1")
    .start(() -> {
        System.out.println("Hello from virtual thread!");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Virtual thread completed!");
    });
// 等待虛擬線程完成
virtualThread.join();

// 創(chuàng)建虛擬線程池
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // 提交任務(wù)到虛擬線程池
    for (int i = 0; i < 1000; i++) {
        final int taskId = i;
        executor.submit(() -> {
            System.out.println("Task " + taskId + " running on " + Thread.currentThread());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return taskId;
        });
    }
}
// 虛擬線程池會(huì)自動(dòng)關(guān)閉

// 使用 StructuredTaskScope 管理虛擬線程
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    // 提交多個(gè)任務(wù)
    Future<String> future1 = scope.fork(() -> {
        Thread.sleep(1000);
        return "Result 1";
    });
    Future<String> future2 = scope.fork(() -> {
        Thread.sleep(500);
        return "Result 2";
    });
    // 等待所有任務(wù)完成
    scope.join();
    // 拋出第一個(gè)失敗的異常
    scope.throwIfFailed();
    // 獲取結(jié)果
    System.out.println("Result 1: " + future1.resultNow());
    System.out.println("Result 2: " + future2.resultNow());
} catch (Exception e) {
    e.printStackTrace();
}

public class VirtualThreadHttpServer {
    public static void main(String[] args) throws IOException {
        var server = HttpServer.create(new InetSocketAddress(8080), 0);
        server.createContext("/", exchange -> {
            // 每個(gè)請(qǐng)求都在獨(dú)立的虛擬線程中處理
            String response = "Hello from virtual thread! " + Thread.currentThread();
            exchange.sendResponseHeaders(200, response.length());
            try (var os = exchange.getResponseBody()) {
                os.write(response.getBytes());
            }
        });
        server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        server.start();
        System.out.println("Server started on port 8080");
    }
}

@Service
public class UserService {
    private final UserRepository repository;
    private final ExecutorService executorService;
    @Autowired
    public UserService(UserRepository repository) {
        this.repository = repository;
        this.executorService = Executors.newVirtualThreadPerTaskExecutor();
    }
    public CompletableFuture<List<User>> getUsers() {
        return CompletableFuture.supplyAsync(() -> {
            // 數(shù)據(jù)庫(kù)查詢操作
            return repository.findAll();
        }, executorService);
    }
    public CompletableFuture<User> createUser(User user) {
        return CompletableFuture.supplyAsync(() -> {
            // 數(shù)據(jù)庫(kù)插入操作
            return repository.save(user);
        }, executorService);
    }
}

public class VirtualThreadFileProcessor {
    public static void main(String[] args) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // 處理多個(gè)文件
            for (int i = 0; i < 100; i++) {
                final int fileId = i;
                executor.submit(() -> {
                    try {
                        // 讀取文件
                        Path path = Path.of("file-" + fileId + ".txt");
                        String content = Files.readString(path);
                        // 處理文件內(nèi)容
                        String processedContent = content.toUpperCase();
                        // 寫入文件
                        Path outputPath = Path.of("output-" + fileId + ".txt");
                        Files.writeString(outputPath, processedContent);
                        System.out.println("Processed file " + fileId + " on " + Thread.currentThread());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                });
            }
        }
    }
}

public class BatchProcessor {
    public List<Result> processBatch(List<Task> tasks) {
        List<CompletableFuture<Result>> futures = new ArrayList<>();
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (Task task : tasks) {
                CompletableFuture<Result> future = CompletableFuture.supplyAsync(() -> {
                    // 處理單個(gè)任務(wù)
                    return processTask(task);
                }, executor);
                futures.add(future);
            }
            // 等待所有任務(wù)完成
            CompletableFuture<Void> allOf = CompletableFuture.allOf(
                futures.toArray(new CompletableFuture[0])
            );
            // 獲取所有結(jié)果
            return allOf.thenApply(v -> 
                futures.stream()
                    .map(CompletableFuture::join)
                    .collect(Collectors.toList())
            ).join();
        }
    }
    private Result processTask(Task task) {
        // 處理任務(wù)的邏輯
        try {
            Thread.sleep(100); // 模擬耗時(shí)操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new Result(task.getId(), "Processed");
    }
}

public class TimeoutExample {
    public String processWithTimeout() {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                try {
                    Thread.sleep(2000); // 模擬耗時(shí)操作
                    return "Success";
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return "Interrupted";
                }
            }, executor);
            // 設(shè)置超時(shí)
            return future.orTimeout(1, TimeUnit.SECONDS)
                .exceptionally(ex -> {
                    if (ex instanceof TimeoutException) {
                        return "Timeout";
                    }
                    return "Error";
                })
                .join();
        }
    }
}

// 推薦的代碼組織結(jié)構(gòu)
com.example
├── service/          // 業(yè)務(wù)邏輯
├── repository/       // 數(shù)據(jù)訪問(wèn)
├── controller/       // 控制器
└── util/             // 工具類

@Configuration
public class ExecutorConfig {
    @Bean(destroyMethod = "close")
    public ExecutorService virtualThreadExecutor() {
        return Executors.newVirtualThreadPerTaskExecutor();
    }
    @Bean(destroyMethod = "shutdown")
    public ExecutorService platformThreadExecutor() {
        return Executors.newFixedThreadPool(10);
    }
}

public class ExceptionHandlingExample {
    public void processTasks(List<Task> tasks) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<CompletableFuture<Void>> futures = tasks.stream()
                .map(task -> CompletableFuture.runAsync(() -> {
                    try {
                        processTask(task);
                    } catch (Exception e) {
                        System.err.println("Error processing task " + task.getId() + ": " + e.getMessage());
                    }
                }, executor))
                .collect(Collectors.toList());
            // 等待所有任務(wù)完成
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        }
    }
    private void processTask(Task task) throws Exception {
        // 處理任務(wù)的邏輯
        if (task.getId() % 5 == 0) {
            throw new Exception("Simulated error");
        }
        Thread.sleep(100);
    }
}