Java 21 新特性来支持并发编程

Java 21 引入了一些新的特性来更好地支持并发编程。这些特性主要集中在语言层面和标准库的改进上，旨在提高性能、简化开发和增强安全性。以下是一些关键的改进点：

### 1. **虚拟线程（Virtual Threads）**
虚拟线程是 Java 21 的一大亮点，它通过 Project Loom 实现。虚拟线程是一种轻量级的线程，可以在单个操作系统线程上运行成千上万个虚拟线程，从而显著减少线程切换的开销。

#### 特点：
- **轻量级**：虚拟线程的创建和销毁成本非常低。
- **高效**：可以在单个操作系统线程上运行多个虚拟线程，减少上下文切换的开销。
- **易于使用**：与传统的 `Thread` 类类似，但性能更好。

#### 示例代码：
```java
public class VirtualThreadsExample {
    public static void main(String[] args) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 1000; i++) {
                executor.submit(() -> {
                    System.out.println("Hello from virtual thread: " + Thread.currentThread().getName());
                });
            }
        }
    }
}
```

### 2. **结构化并发（Structured Concurrency）**
结构化并发是一种编程模型，旨在使并发代码更加安全和易于理解。它通过将并发任务组织成结构化的单元来管理任务的生命周期，从而减少错误和死锁的风险。

#### 特点：
- **任务分组**：将并发任务分组，以便统一管理和取消。
- **异常传播**：确保子任务的异常能够正确传播到父任务。
- **资源管理**：自动管理任务的生命周期，确保资源的正确释放。

#### 示例代码：
```java
public class StructuredConcurrencyExample {
    public static void main(String[] args) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var future1 = scope.fork(() -> {
                System.out.println("Task 1 running in virtual thread: " + Thread.currentThread().getName());
                return "Result 1";
            });

            var future2 = scope.fork(() -> {
                System.out.println("Task 2 running in virtual thread: " + Thread.currentThread().getName());
                return "Result 2";
            });

            scope.join();  // Wait for all tasks to complete
            scope.throwIfFailed();  // Propagate any exceptions

            System.out.println("Task 1 result: " + future1.get());
            System.out.println("Task 2 result: " + future2.get());
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

### 3. **改进的 `ForkJoinPool`**
Java 21 对 `ForkJoinPool` 进行了一些优化，使其在处理大量任务时更加高效。

#### 特点：
- **更好的负载均衡**：改进了任务的分发和窃取机制，减少了空闲线程的数量。
- **更低的延迟**：优化了任务的调度算法，减少了任务的等待时间。

#### 示例代码：
```java
public class ForkJoinPoolExample {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();

        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        int sum = pool.invoke(new SumTask(array, 0, array.length));

        System.out.println("Sum: " + sum);
    }

    static class SumTask extends RecursiveTask<Integer> {
        private final int[] array;
        private final int start;
        private final int end;

        public SumTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            if (end - start <= 10) {
                int sum = 0;
                for (int i = start; i < end; i++) {
                    sum += array[i];
                }
                return sum;
            } else {
                int mid = (start + end) / 2;
                SumTask leftTask = new SumTask(array, start, mid);
                SumTask rightTask = new SumTask(array, mid, end);

                leftTask.fork();
                int rightResult = rightTask.compute();
                int leftResult = leftTask.join();

                return leftResult + rightResult;
            }
        }
    }
}
```

### 4. **改进的 `CompletableFuture`**
Java 21 对 `CompletableFuture` 进行了一些增强，使其在处理异步任务时更加灵活和强大。

#### 特点：
- **更好的错误处理**：改进了异常处理机制，使得错误传播更加清晰。
- **更多的组合操作**：增加了新的组合操作方法，使得异步任务的组合更加方便。

#### 示例代码：
```java
public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            return "Hello";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            return "World";
        });

        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> {
            return result1 + " " + result2;
        });

        combinedFuture.thenAccept(result -> {
            System.out.println(result);  // 输出: Hello World
        });

        // 等待所有异步任务完成
        combinedFuture.join();
    }
}
```

### 总结
Java 21 通过引入虚拟线程、结构化并发、改进的 `ForkJoinPool` 和增强的 `CompletableFuture`，在并发编程方面进行了显著的改进。这些特性不仅提高了性能，还简化了开发和维护，使得编写高效的并发代码变得更加容易。希望这些信息对你有帮助！如果还有其他问题，请随时告诉我。