Java并发工具库：Fork/Join， CompletableFuture 和 CyclicBarrier 实例

原创心已赠人 2024-11-06 10:42 8阅读 0赞

Java并发工具库提供了多种工具来帮助开发者编写并发程序。以下是`Fork/Join`、`CompletableFuture`和`CyclicBarrier`三个工具的简单实例。

###1. Fork/Join`Fork/Join`框架是Java7引入的，用于将大任务分解成小任务并行处理，最后合并结果。它基于`RecursiveAction`和`RecursiveTask`两个抽象类。

```javaimport java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinExample {
 static class SumTask extends RecursiveTask<Long> {
 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 Long compute() {
if (end - start <= THRESHOLD) {
 return sum();
} else {
int middle = (start + end) /2;
 SumTask subtask1 = new SumTask(array, start, middle);
 SumTask subtask2 = new SumTask(array, middle, end);

subtask1.fork();
 subtask2.fork();

return subtask1.join() + subtask2.join();
 }
 }

private long sum() {
 long sum =0;
 for (int i = start; i < end; i++) {
sum += array[i];
 }
 return sum;
 }
 }

public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7,8,9,10};
 SumTask task = new SumTask(array,0, array.length);
 ForkJoinPool pool = new ForkJoinPool();
 long result = pool.invoke(task);
 System.out.println("Sum: " + result);
 }
}
```###2. CompletableFuture`CompletableFuture`是Java8引入的，用于编写异步代码。它提供了`supplyAsync`、`thenApply`、`thenCombine`等方法。

```javaimport java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
 public static void main(String[] args) throws ExecutionException, InterruptedException {
 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
//模拟耗时操作 try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 return "Hello";
 });

future.thenApplyAsync(s -> s + " World").thenAcceptAsync(System.out::println);
 }
}
```###3. CyclicBarrier`CyclicBarrier`用于让一组线程等待彼此达到某个公共屏障点。当所有线程都到达屏障点时，它们可以继续执行。

```javaimport java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicBarrierExample {
 public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("所有线程都到达屏障点"));

ExecutorService executor = Executors.newFixedThreadPool(3);

for (int i =0; i <3; i++) {
 executor.submit(() -> {
 try {
 System.out.println(Thread.currentThread().getName() + "到达屏障点");
 barrier.await();
 System.out.println(Thread.currentThread().getName() + "继续执行");
} catch (Exception e) {
e.printStackTrace();
 }
 });
 }

executor.shutdown();
 }
}
```这三个工具各有特点，适用于不同的并发场景。`Fork/Join`适合任务分解和合并，`CompletableFuture`适合异步编程，`CyclicBarrier`适合线程同步。根据具体需求选择合适的工具。