多线程控制工具类CountDownLatch/CyclicBarrier

CountDownLatch

CountDownLatch是一个多线程控制工具类，这个工具类用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

（1）CountDownLatch的构造函数

public CountDownLatch(int count)

CountDownLatch的构造函数接收一个整数作为参数，即为当前这个计数器的计数个数。

（2）CountDownLatch类中的方法

1）public void await() throws InterruptedException{};

调用await方法的线程会被挂起，直至count值为0后才会继续执行。

2）public void countdown();

count值减1。

3）public void await(long timeout,TimeUnit unit) throws InterruptedException{};

与await方法类似，只是在等待一定的时间之后，count值还没有变为0，会继续执行。

package com.example.demo.test;

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

public class CountDownLatchDemo implements Runnable{


    static final CountDownLatch countDownLatch = new CountDownLatch(10);

    static final CountDownLatchDemo countDownLatchDemo = new CountDownLatchDemo();

    @Override
    public void run() {

        try {

            Thread.sleep(3000);

            System.out.println("检查是否完成！");

            countDownLatch.countDown();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

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

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        for (int i=0;i<10;i++){

            executorService.submit(countDownLatchDemo);

        }

        countDownLatch.await();

        System.out.println("开始！");

        executorService.shutdown();

    }
}

CyclicBarrier

CyclicBarrier也是一种多线程并发控制实用工具，也可以实现线程间的计数等待。

package com.example.demo.test;

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

public class CyclicBarrierDemo {

    public static void main(String[] args) {

        final int N = 10;

        Thread [] allSoldier = new Thread[N];

        boolean flag = false;

        CyclicBarrier cyclicBarrier = new CyclicBarrier(N,new BarrierRun(false,N));

        System.out.println("队伍集合！");

        for(int i=0;i<N;i++){

            System.out.println("士兵"+i+"报道！");

            allSoldier[i] = new Thread(new Soldier(cyclicBarrier,"士兵"+i));

            allSoldier[i].start();

        }


    }

    public static class Soldier implements Runnable{

        private String soldier;

        private final CyclicBarrier cyclicBarrier;

        public Soldier(CyclicBarrier cyclicBarrier,String soldier){

            this.soldier = soldier;

            this.cyclicBarrier = cyclicBarrier;

        }

        @Override
        public void run() {

            try {

                cyclicBarrier.await();

                doWork();

            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }


        }


        public 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;

        }

        @Override
        public void run() {

            if(flag){

                System.out.println("司令：【士兵"+N+"个，任务完成！】");


            }else{

                System.out.println("司令：【士兵"+N+"个，集合完毕！】");

                flag = true;

            }

        }
    }


}