Java中如何并发执行3个方法并在全部完成后执行指定方法？

当然可以实现这个需求，Java提供了多种成熟的并发工具来达成目标，以下是三种常用的实现方案：

方案1：使用CountDownLatch #

CountDownLatch 是java.util.concurrent包下的同步工具类，通过计数器实现线程等待逻辑：初始化时设置计数器值为需要等待的任务数量，每个任务执行完毕后调用countDown()将计数器减1，主线程调用await()阻塞等待，直到计数器归0后再执行后续方法。

示例代码：

import java.util.concurrent.CountDownLatch;

public class ConcurrentDemo {
    public void methodOne() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }

    public void methodTwo() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
    }

    public void methodThree() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }

    public void methodCompleted() {
        System.out.println("All functions completed");
    }

    public static void main(String[] args) throws InterruptedException {
        ConcurrentDemo demo = new ConcurrentDemo();
        CountDownLatch latch = new CountDownLatch(3);

        // 启动三个线程分别执行三个方法
        new Thread(() -> {
            demo.methodOne();
            latch.countDown();
        }).start();

        new Thread(() -> {
            demo.methodTwo();
            latch.countDown();
        }).start();

        new Thread(() -> {
            demo.methodThree();
            latch.countDown();
        }).start();

        // 等待三个方法全部执行完成
        latch.await();
        // 执行后续方法
        demo.methodCompleted();
    }
}

方案2：使用ExecutorService的invokeAll方法 #

ExecutorService 提供的invokeAll()方法可以批量提交多个Callable任务，并阻塞等待所有任务执行完成后再继续执行后续逻辑，适合管理多个并发任务的场景。

示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentDemo {
    public void methodOne() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }

    public void methodTwo() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
    }

    public void methodThree() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }

    public void methodCompleted() {
        System.out.println("All functions completed");
    }

    public static void main(String[] args) throws Exception {
        ConcurrentDemo demo = new ConcurrentDemo();
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        List<Runnable> tasks = new ArrayList<>();
        tasks.add(demo::methodOne);
        tasks.add(demo::methodTwo);
        tasks.add(demo::methodThree);

        // 将Runnable转换为Callable并提交，invokeAll等待所有任务完成
        executor.invokeAll(tasks.stream().map(task -> (java.util.concurrent.Callable<Void>) () -> {
            task.run();
            return null;
        }).toList());

        // 关闭线程池
        executor.shutdown();
        // 执行后续方法
        demo.methodCompleted();
    }
}

方案3：使用CompletableFuture（Java 8及以上） #

CompletableFuture 是Java 8引入的异步编程工具，支持链式调用和任务编排，allOf()方法可以等待多个异步任务全部完成，之后通过thenRun()指定后续执行的方法，代码更简洁优雅。

示例代码：

import java.util.concurrent.CompletableFuture;

public class ConcurrentDemo {
    public void methodOne() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }

    public void methodTwo() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
    }

    public void methodThree() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }

    public void methodCompleted() {
        System.out.println("All functions completed");
    }

    public static void main(String[] args) {
        ConcurrentDemo demo = new ConcurrentDemo();

        // 异步执行三个方法
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(demo::methodOne);
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(demo::methodTwo);
        CompletableFuture<Void> future3 = CompletableFuture.runAsync(demo::methodThree);

        // 等待所有异步任务完成后执行methodCompleted
        CompletableFuture.allOf(future1, future2, future3).thenRun(demo::methodCompleted).join();
    }
}

内容的提问来源于stack exchange，提问作者Nicole Foster