CountDownLatch类 和 CyclicBarrier类 详解与区别

目录

 

1. CountDownLatch 类

1.1. 常用方法

2. CyclicBarrier类

2.1. 常用方法

---

1. CountDownLatch 类

CountDownLatch 类是用于线程同步的工具，（接下来的一句话对于刚接触这个类的读者来说，很难理解，不妨先看看后面的）作用：让一个或多个源线程（调用await方法的线程） 必须 等待一个或多个目标线程（调用countDown方法的线程）都执行完成了才能继续执行自己的代码。

举个例子：一个公司有3名员工（3个目标线程）和1名保安（1个源线程），下班的时候，保安必须在门口等着，什么也不能干，相当于停顿在那，具体等什么呢？等3名员工都离开公司，一旦3名员工都离开了，保安才能进一步执行工作（关门）。对于这样的一个场景，保安可以利用CountDownLatch工具实现。

保安怎么实现呢？创建一个CountDownLatch对象，这个对象里有个计数器count，保安初始化这个计数器为3，到了该下班的时候，保安调用await()方法使自己处于“在门口等待”，然后每个员工在离开公司大门的时候，都调用一下countDown()方法，将计数器减1，当3个员工都离开后，计数器变为了0，那保安什么时候可以动了呢，就是在计数器为0的时候，保安就可以动力，去锁门，然后保安就下班了，自由活动。

注意：

1. 不会妨碍目标线程的执行，但是会阻塞源线程，因为await方法会检测count是为0，如果不是0，就会阻塞，不会继续执行后面的代码。 

2. 它是一次性的，不能重复用，因为count变为0之后，就不会再改变了，只有一个countDown方法去减，没有方法去让count加，所以如果你重复使用的话，不起作用，count永远为0。

3. 当然，你可以在一个线程的run方法里调用多次countDown 方法，多减几个1。

1.1. 常用方法

public CountDownLatch(int count); //构造方法，初始化计数器。

public void await(); //线程调用此方法后，会阻塞等待，等待计数器为0时才能继续执行。

public boolean await(long timeout, TimeUnit unit); //线程在规定的时间内等待计数器变为0，如果等不到，就不等了，仍然继续执行，如果等到了，也是继续执行。

public void countDown(); //将计数器减1。

public void getDown(); //获取当前计数器的值。

下面是源码的简单介绍：

public class CountDownLatch {
    // 构造方法，初始化计数值
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    //判断count是否为0，为0才能继续执行下去，否则就一直阻塞
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    //判断count是否为0，为0才能继续执行下去，否则就一直阻塞，如果阻塞时间超过了unit，就继续执行
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    //让count减1
    public void countDown() {
        sync.releaseShared(1);
    }

    //获取count的值
    public long getCount() {
        return sync.getCount();
    }
}

举个例子：

其实这个例子里面不应该将CountDownLatch对象定为静态的（定义为普通的就行），因为不能重复使用，定义为静态的干嘛。

public class Main {
    public static CountDownLatch countDownLatch = new CountDownLatch(2);
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        MyThread myThread1 = new MyThread();
        myThread1.start();
        countDownLatch.await();
        System.out.println("彻底结束啦");
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("当前线程是：" + Thread.currentThread().getName());
        Main.countDownLatch.countDown();
        System.out.println("结束");
    }
}

2. CyclicBarrier类

CyclicBarrier 类也是线程同步工具类，CountDownLatch类能做到的，它都能做到，而且功能更多，作用：仅仅让多个线程同时开始执行。 形象地比喻为栅栏，所有达到栅栏的线程都得停下，只能线程数量达到了规定的数量后，才打开栅栏，让所有线程同时继续运行。

还是举保安的例子，每个员工上班到达公司的时间不相同，但是保安在门口设置了一个栅栏，每满10个人才打开栅栏让这10个人进去上班，所以说你先到公司门口也没用，不让进，你得等着，等凑够10个人，你才能进去。

注意：

1. 它不会阻塞源线程，但是它阻塞目标线程。

2. 能够重复使用，就好像count减为0之后，会自动将计数器恢复成初始数值。

2.1. 常用方法

1、public CyclicBarrier(int parties, Runnable barrierAction); //构造方法，parties类似于计数器，barrierAction是一个线程，这个线程由最后一个到达栅栏的线程执行。

2、public CyclicBarrier(int parties); //构造方法。

3、public int getNumberWaiting(); //获取当前在栅栏处等待的线程数量。

4、public int getParties(); //获取计数器的初始值。

5、public int await(); //线程调用此方法表明自己已经到达栅栏，准备就绪。

6、public int await(long timeout, TimeUnit unit); //线程调用此方法表明自己已经到达栅栏，等待其它线程到达栅栏，但是如果在此时间内达到栅栏的线程数量不够，那么就抛出异常。

7、public void reset(); //重置计数器为初始化值。

public class CyclicBarrier {
    //用于记录同一批线程属于一代
    private static class Generation {
        boolean broken = false; 
    }
    //入口锁，就是要达到栅栏，也得一个一个来吧，不能两个线程同时进行吧，因此要一个锁
    private final ReentrantLock lock = new ReentrantLock();
    //条件锁，当线程到达栅栏时，锁住它，不让其执行，等线程数量满足条件后，锁打开，线程继续执行
    private final Condition trip = lock.newCondition();
    // 记录栅栏开启所需的线程数，以便重置的时候使用
    private final int parties;
    //线程数量达到要求后，执行的内容
    private final Runnable barrierCommand;
    private Generation generation = new Generation();
    //count类似于CountDownLatch中的count
    private int count;
    //进入下一代了，上一批线程已经处理完了，可以接受下一批了
    private void nextGeneration() {
        trip.signalAll();
        count = parties;
        generation = new Generation();
    }
    //终止栅栏
    private void breakBarrier() {
        generation.broken = true;
        count = parties;
        trip.signalAll();
    }

    //await就是通过dowait实现的
    private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            final Generation g = generation;

            if (g.broken)
                throw new BrokenBarrierException();

            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }

            int index = --count;
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    if (command != null)
                        command.run();
                    ranAction = true;
                    nextGeneration();
                    return 0;
                } finally {
                    if (!ranAction)
                        breakBarrier();
                }
            }

            // loop until tripped, broken, interrupted, or timed out
            for (;;) {
                try {
                    if (!timed)
                        trip.await();
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {
                    if (g == generation && ! g.broken) {
                        breakBarrier();
                        throw ie;
                    } else {
                        // We're about to finish waiting even if we had not
                        // been interrupted, so this interrupt is deemed to
                        // "belong" to subsequent execution.
                        Thread.currentThread().interrupt();
                    }
                }

                if (g.broken)
                    throw new BrokenBarrierException();

                if (g != generation)
                    return index;

                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }

    //构造方法，当栅栏被开启时，barrierAction由最后一个到达栅栏的线程执行
    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

    // 构造方法
    public CyclicBarrier(int parties) {
        this(parties, null);
    }

    // 获取打开栅栏所需的线程数量，就是我们初始化时候指定的那个int参数
    public int getParties() {
        return parties;
    }

    // 调用这个方法的线程已经就绪等待了
    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }

    // 这个方法是目标线程调用的，表示调用此方法的线程已经就绪等待着，
    // 如果等待时间超过unit，就不等了，直接执行自己的
    public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException {
        return dowait(true, unit.toNanos(timeout));
    }

    // 判断栅栏是否被破坏
    public boolean isBroken() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return generation.broken;
        } finally {
            lock.unlock();
        }
    }

    // 重置为初始化状态，如果此时有线程在等待，线程会抛出异常
    public void reset() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            breakBarrier();   // break the current generation
            nextGeneration(); // start a new generation
        } finally {
            lock.unlock();
        }
    }

    // 获取当前正等待着的（或者说准备就绪了）线程的数量
    public int getNumberWaiting() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return parties - count;
        } finally {
            lock.unlock();
        }
    }
}