Java等待异步线程池跑完再执行指定方法的三种方式(condition、CountDownLatch、CyclicBarrier)

Java等待异步线程池跑完再执行指定方法的三种方式(condition、CountDownLatch、CyclicBarrier)

@Async如何使用

使用@Async标注在方法上，可以使该方法异步的调用执行。而所有异步方法的实际执行是交给TaskExecutor的。

1.启动类添加@EnableAsync注解
2. 方法上添加@Async，类上添加@Component

三个异步方法

    @Async
    public void doTaskTwo( CyclicBarrier barry) throws Exception {
        System.out.println("开始做任务二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(3000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
        barry.await();
    }

    @Async
    public void doTaskThree( CyclicBarrier barry) throws Exception {
        System.out.println("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(5000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
        barry.await();
    }

    @Override
    @Async
    public void doTask2One(CountDownLatch count) throws Exception {
        System.out.println("开始做任务1");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(3000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务1，耗时：" + (end - start) + "毫秒");
        count.countDown();
    }

CyclicBarrier

@GetMapping("/doTask")
    public void doLogin() throws Exception {

        // 通过它可以实现让一组线程等待至某个状态之后再全部同时执行
        //第一个参数，表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
        //第二个参数，表示用于在线程到达屏障时，优先执行barrierAction这个Runnable对象，方便处理更复杂的业务场景。
        CyclicBarrier barry = new CyclicBarrier(3, new Runnable() {
            @Override
            public void run() {
                System.out.println("1111111111111");
            }
        });
        kafkaTopicService.doTaskOne(barry);
        kafkaTopicService.doTaskTwo(barry);
        kafkaTopicService.doTaskThree(barry);


    }

执行结果

开始做任务一
开始做任务二
开始做任务三
完成任务一，耗时：1263毫秒
完成任务二，耗时：2508毫秒
完成任务三，耗时：3753毫秒
1111111111111

注意: 接口响应成功时候后台逻辑还在走
CyclicBarrier 的使用场景也很丰富。

比如，司令下达命令，要求 10 个士兵一起去完成项任务。

这时就会要求 10 个士兵先集合报到，接着，一起雄赳赳，气昂昂地去执行任务当 10 个士兵把自己手上的任务都执行完了，那么司令才能对外宣布，任务完成

CyclicBarrier 比 CountDownLatch 略微强大一些，它可以接收一个参数作为 barrierAction。

所谓 barrierAction 就是当计数器一次计数完成后，系统会执行的动作。

如下构造函数，其中， parties 表示计数总数，也就是参与的线程总数。

public CyclicBarrier(int parties, Runnable barrierAction) 


package com.shockang.study.java.concurrent.aqs;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static class Soldier implements Runnable {
        private String soldier;
        private final CyclicBarrier cyclic;

        Soldier(CyclicBarrier cyclic, String soldierName) {
            this.cyclic = cyclic;
            this.soldier = soldierName;
        }

        public void run() {
            try {
                //等待所有士兵到齐 第一次等待
                cyclic.await();
                doWork();
                //等待所有士兵完成工作 第二次等待
                cyclic.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }

        void doWork() {
            try {
                Thread.sleep(Math.abs(new Random().nextInt() % 10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(soldier + ":任务完成");
        }
    }

    public static class BarrierRun implements Runnable {
        boolean flag;
        int N;

        public BarrierRun(boolean flag, int N) {
            this.flag = flag;
            this.N = N;
        }

        public void run() {
            if (flag) {
                System.out.println("司令:[士兵" + N + "个，任务完成！]");
            } else {
                System.out.println("司令:[士兵" + N + "个，集合完毕！]");
                flag = true;
            }
        }
    }

    public static void main(String args[]) throws InterruptedException {
        final int N = 10;
        Thread[] allSoldier = new Thread[N];
        boolean flag = false;
        CyclicBarrier cyclic = new CyclicBarrier(N, new BarrierRun(flag, N));
        //设置屏障点，主要是为了执行这个方法
        System.out.println("集合队伍！");
        for (int i = 0; i < N; ++i) {
            System.out.println("士兵 " + i + " 报道！");
            allSoldier[i] = new Thread(new Soldier(cyclic, "士兵 " + i));
            allSoldier[i].start();
        }
    }
}

控制台输出

集合队伍！
士兵 0 报道！
士兵 1 报道！
士兵 2 报道！
士兵 3 报道！
士兵 4 报道！
士兵 5 报道！
士兵 6 报道！
士兵 7 报道！
士兵 8 报道！
士兵 9 报道！
司令:[士兵10个，集合完毕！]
士兵 0:任务完成
士兵 3:任务完成
士兵 6:任务完成
士兵 4:任务完成
士兵 9:任务完成
士兵 8:任务完成
士兵 2:任务完成
士兵 5:任务完成
士兵 7:任务完成
士兵 1:任务完成
司令:[士兵10个，任务完成！]

说明

上述代码第 65 行创建了 CyclicBarrier 实例，并将计数器设置为 10 ，要求在计数器达到指标时，执行第 51 行的 run() 方法。

每一个士兵线程都会执行第 18 行定义的 run() 方法。

在第 24 行，每一个士兵线程都会等待，直到所有的士兵都集合完毕。

集合完毕意味着 CyclicBarrier 的一次计数完成，当再一次调用 CyclicBarrier.await() 方法时，会进行下一次计数。

第 22 行模拟了士兵的任务。

当一个士兵任务执行完，他就会要求 CyclicBarrier 开始下次计数，这次计数主要目的是监控是否所有的士兵都己经完成了任务。

一旦任务全部完成，第 42 行定义的 BarrierRun 就会被调用，打印相关信息。

2、CountDownLatch

 @GetMapping("/doTask2")
    public void doTask2() throws Exception {

        CountDownLatch count = new CountDownLatch(3);

        kafkaTopicService.doTask2One(count);
        kafkaTopicService.doTask2Two(count);
        kafkaTopicService.doTask2Three(count);
        count.await();
        System.out.println("11111111111111111");

    }

执行结果:

开始做任务1
开始做任务二
开始做任务3
完成任务1，耗时：179毫秒
完成任务3，耗时：1829毫秒
完成任务二，耗时：2376毫秒
11111111111111111

注意: 接口响应成功时候后台逻辑已经走完

1、juc中condition接口提供的await、signal、signalAll方法，需配合lock

List<Integer> villageList = new ArrayList<>();
    List<Integer> villageList2 = new ArrayList<>();
    villageList.add(1);
    villageList.add(2);
    villageList.add(3);
    ExecutorService threadPool = Executors.newFixedThreadPool(2);

    Lock lock = new ReentrantLock();
    Condition cond = lock.newCondition();
    for(int flag = 0;flag<villageList.size();flag++){
        Integer i = villageList.get(flag);
        threadPool.execute(() -> {
            try {
                villageList2.add(i);
            } catch (Exception e) {
                e.printStackTrace();
            }
            if(villageList2.size() == villageList.size()){
                lock.lock();
                cond.signal();
                lock.unlock();
            }
        });
    }
    lock.lock();
    try {
        cond.await(5, TimeUnit.SECONDS);
        lock.unlock();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(villageList2.size());
    threadPool.shutdown();
}

CountDownLatch和CyclicBarrier的比较

1.CountDownLatch是减计数方式，countDown()方法只参与计数不会阻塞线程，而CyclicBarrier是加计数方式，await()方法参与计数，会阻塞线程。

2.CountDownLatch计数为0无法重置，而CyclicBarrier计数达到初始值，则可以重置，因此CyclicBarrier可以复用。

附:CountDownLatch有发令枪的效果，可以用来并发测试

public class test2 {

    private final static CountDownLatch CountDownLatch=new CountDownLatch(100);

    public static void main(String[] args) throws Exception{

        for (int i=0;i<100;i++){
            new Thread(() -> {
                try {
                    CountDownLatch.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                getUUID();
            }).start();
            CountDownLatch.countDown(); //如果减到0 统一出发,发枪开炮

        }
    }

    public static void getUUID(){
        UUID uuid= UUID.randomUUID();
        System.out.println(uuid);
    }
}

注意事项

CountDownLatch 对象的计数器只能减不能增，即一旦计数器为 0，就无法再重新设置为其他值，因此在使用时需要根据实际需要设置初始值。
CountDownLatch 的计数器是线程安全的，多个线程可以同时调用 countDown() 方法，而不会产生冲突。
如果 CountDownLatch 的计数器已经为 0，再次调用 countDown() 方法也不会产生任何效果。
如果在等待过程中，有线程发生异常或被中断，计数器的值可能不会减少到 0，因此在使用时需要根据实际情况进行异常处理。

当worker1线程由于异常没有执行countDown()方法，最后state结果不为0，导致所有线程停在AQS中自旋（死循环）。所以程序无法结束。（如何解决这个问题呢？请看案例二）

// 等待 3 个线程完成任务
if (!latch.await(5, TimeUnit.SECONDS)) {
    LOGGER.warn("{} time out", worker1.name);
}
 
// 所有线程完成任务后，执行下面的代码
LOGGER.info("all workers have finished their jobs!");

CountDownLatch 可以与其他同步工具（如 Semaphore、CyclicBarrier）结合使用，实现更复杂的多线程同步。