任务T1、T2、T3并发执行，最后执行任务T4的实现方法

2021年9月12日面试茄子快传的时候，提到三个任务T1、T2、T3的执行需要并发执行，且最后执行任务T4。那么应该怎么实现。

当时有点忘记了具体的实现，只知道在Java中，如果抽象为线程任务，那么有两种机制可以用来实现：

• Thread提供的join方法；
• 使用JUC下面的CountDownLatch类；

这里来简单使用下这两种方法。

1. join方法来实现

等待线程执行终止。
在主线程中如果对子线程使用了join方法，那么主线程会等待join的线程执行完毕，当所有的执行完毕后，再继续向下执行主线程。

故而在当前的场景下，可以构建如下代码：

public class Main {

    private static volatile int[] arr = new int[4];

    private static class ThreadFactory{
        private static AtomicInteger number = new AtomicInteger(1);
        private ThreadFactory(){}
        public static Thread createThread(Runnable r){
            return new Thread(r, "Task#" + number.getAndIncrement());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = ThreadFactory.createThread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    arr[0] += 10;
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + arr[0]);
                }
            }
        });

        thread1.start();

        Thread thread2 = ThreadFactory.createThread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    arr[1] += 20;
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + arr[1]);
                }
            }
        });

        thread2.start();

        Thread thread3 = ThreadFactory.createThread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    arr[2] += 30;
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + arr[2]);
                }
            }
        });

        thread3.start();

        thread1.join();
        thread2.join();
        thread3.join();

        // Task 4默认为主线程即可
        arr[3] = arr[0] + arr[1] + arr[2];

        for (int i : arr) {
            System.out.print(i+"\t");
        }
        System.out.println();
    }

}

结果：

从上面结果可以看出满足了T1、T2、T3并发执行，最后执行任务T4的要求。

2. CountDownLatch类来实现

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。当计数器数值减为0时，所有受其影响而等待的线程将会被激活。

CountDownLatch主要两个方法就是一是CountDownLatch.await()阻塞当前线程，二是CountDownLatch.countDown()当前线程把计数器减一。

对应的实现：

public class Main {

    private static volatile int[] arr = new int[4];

    private static class ThreadFactory{
        private static AtomicInteger number = new AtomicInteger(1);
        private ThreadFactory(){}
        public static Thread createThread(Runnable r){
            return new Thread(r, "Task#" + number.getAndIncrement());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);  // 这里需要三个并发，故而这里设置值为3

        Thread thread1 = ThreadFactory.createThread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    arr[0] += 10;
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + arr[0]);
                }
                // 这个线程执行完毕，进行释放
                countDownLatch.countDown();
            }
        });

        thread1.start();

        Thread thread2 = ThreadFactory.createThread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    arr[1] += 20;
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + arr[1]);
                }
                // 这个线程执行完毕，进行释放
                countDownLatch.countDown();
            }
        });

        thread2.start();

        Thread thread3 = ThreadFactory.createThread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    arr[2] += 30;
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + arr[2]);
                }
                // 这个线程执行完毕，进行释放
                countDownLatch.countDown();
            }
        });

        thread3.start();


        // Task 4默认为主线程即可
        // 首先阻塞一下
        countDownLatch.await();
        arr[3] = arr[0] + arr[1] + arr[2];

        for (int i : arr) {
            System.out.print(i+"\t");
        }
        System.out.println();

    }

}

结果：