Java ExecutorService如何实现任务依赖关系

在Java中，ExecutorService本身并不直接支持任务之间的依赖关系。但是，你可以通过以下几种方法来实现任务之间的依赖关系：

1. 使用CountDownLatch：

CountDownLatch是一个同步工具类，它允许一个或多个线程等待直到一组操作完成。你可以使用CountDownLatch来确保在执行依赖于其他任务的任务之前，其他任务已经完成。

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

public class TaskDependencyExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 任务1
        executorService.submit(() -> {
            System.out.println("Task 1");
        });

        // 任务2
        executorService.submit(() -> {
            System.out.println("Task 2");
        });

        // 任务3依赖于任务1和任务2
        CountDownLatch latch = new CountDownLatch(2);
        executorService.submit(() -> {
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task 3");
        });

        executorService.shutdown();
    }
}

2. 使用CompletableFuture：

CompletableFuture是Java 8引入的一个类，它表示一个异步计算的结果。你可以使用CompletableFuture来组合多个任务，并指定它们之间的依赖关系。

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

public class TaskDependencyExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 任务1
        CompletableFuture<Void> task1 = CompletableFuture.runAsync(() -> {
            System.out.println("Task 1");
        }, executorService);

        // 任务2
        CompletableFuture<Void> task2 = CompletableFuture.runAsync(() -> {
            System.out.println("Task 2");
        }, executorService);

        // 任务3依赖于任务1和任务2
        CompletableFuture<Void> task3 = CompletableFuture.allOf(task1, task2).thenRun(() -> {
            System.out.println("Task 3");
        });

        task3.join();

        executorService.shutdown();
    }
}

3. 使用ForkJoinPool和RecursiveTask：

如果你的任务可以分解为更小的子任务，并且这些子任务之间存在依赖关系，你可以使用ForkJoinPool和RecursiveTask来实现任务之间的依赖关系。

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

public class TaskDependencyExample {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();

        // 任务1
        RecursiveTask<Integer> task1 = new RecursiveTask<Integer>() {
            @Override
            protected Integer compute() {
                System.out.println("Task 1");
                return 1;
            }
        };

        // 任务2
        RecursiveTask<Integer> task2 = new RecursiveTask<Integer>() {
            @Override
            protected Integer compute() {
                System.out.println("Task 2");
                return 1;
            }
        };

        // 任务3依赖于任务1和任务2
        RecursiveTask<Integer> task3 = new RecursiveTask<Integer>() {
            @Override
            protected Integer compute() {
                task1.fork();
                task2.fork();
                task1.join();
                task2.join();
                System.out.println("Task 3");
                return 1;
            }
        };

        forkJoinPool.invoke(task3);
        forkJoinPool.shutdown();
    }
}

这些方法可以帮助你在Java中实现任务之间的依赖关系。你可以根据你的需求选择合适的方法。