CountDownLatch与CyclicBarrier原理剖析

少不入川。

已于 2023-05-29 16:31:55 修改

阅读量2k

点赞数

分类专栏： JUC 文章标签： CountDownLatch CyclicBarrier 源码 JDK8 并发编程

于 2023-02-26 11:57:11 首次发布

本文链接：https://blog.csdn.net/qq_52002412/article/details/129225114

版权

JUC 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.CountDownLatch

1.1 什么是CountDownLatch

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

1.2 CountDownLatch与join

使用join同样可以达到线程同步的效果，但是调用thread.join() 方法必须等thread 执行完毕，当前线程才能继续往下执行，而CountDownLatch通过计数器提供了更灵活的控制，只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。

而且如果我们使用线程池的话，就没有办法直接调用线程的join方法了。所有另一方面来说，CountDownLatch要比join更加灵活。

1.3 CountDownLatch的基本使用

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
    
        CountDownLatch latch = new CountDownLatch(5);

        for (int i=0; i<=5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " 运行");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        latch.countDown();
                    }
                }
            }).start();
        }

        System.out.println("等待子线程运行结束");
        latch.await();
        System.out.println("子线程运行结束");
    }
}

这里主线程会阻塞在latch.await()，直到CountDownLatch技术为0。

1.4 CountDownLatch原理剖析

CountDownLatch类图

请添加图片描述

从上面我们可以直到Sync继承了AQS类，CountDownLatch又持有一个成员变量Sync，所有我们可以直到CountDownLatch是基于AQS实现的。

通过构造方法我们又可以得知CountDownLatch计数器的值赋给了AQS的state变量。

public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

Sync(int count) {
    setState(count);
}

await()

await()的作用是使当前线程等待，直到闩锁倒计时到零（state为0），除非线程中断。
当线程调用await方法以后，当前线程会被阻塞，直到下面情况之一时才会返回：

当所有的线程都调用了CountDownLatch的countDown方法后，也就是计数器为0时
其他线程调用了当前线程的interrupt()方法中断了当前线程，当前线程会抛出异常然后返回

// CountDownLatch的await()实现
public void await() throws InterruptedException {
	// 尝试获取共享资源
    sync.acquireSharedInterruptibly(1);
}

// AQS中获取共享资源可被中断的方法
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
        
    // 判断当前线程是否已被标记为中断，如果是则抛出异常不继续往下执行
    if (Thread.interrupted())
        throw new InterruptedException();

    // 首先执行CountDownLatch中的内部类Sync的tryAcquireShared()方法，也就是判断当前state是否已经减为0，如果没有则执行AQS的doAcquireSharedInterruptibly方法，目的是让当前线程进入AQS阻塞队列
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

// CountDownLatch中的Sync中tryAcquireShared()方法
protected int tryAcquireShared(int acquires) {
	// state不为0（意味着CountDownLatch还没有减到0）
    // 不为0则返回-1，然后调用doAcquireSharedInterruptibly()方法将当前线程放入AQS队列
    return (getState() == 0) ? 1 : -1;
}

由上述代码我们可以知道线程获取资源时可以被中断，并且获取的是共享资源。

名为await的方法还有一个，不过多个参数，也就是指定时间后，调用await(long timeout, TimeUnit unit)的线程会超时而返回false，如果是正常返回的，那么返回值就为true。

public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

countDown()

线程调用该方法以后，计数器的值会递减，递减后如果计数器的值为0，那么就会唤醒所有因调用await方法而阻塞的线程，否则什么都不做。

// CountDownLatch中的countDown方法
public void countDown() {
    sync.releaseShared(1);
}

// sync继承自AQS的releaseShared()方法
public final boolean releaseShared(int arg) {

    // 调用Sync实现的tryReleaseShared方法
    if (tryReleaseShared(arg)) {
        // AQS中释放资源的方法，也就是激活调用await()方法被阻塞进入AQS队列的线程
        doReleaseShared();
        return true;
    }
    return false;
}


// Sync中重写的tryReleaseShared方法
// 作用是将state变量减去releases
protected boolean tryReleaseShared(int releases) {
    // 循环进行CAS操作，将state做减一操作，失败则一直重试
    for (;;) {
    
        // 获得当前的state变量
        int c = getState();
        
        // 如果state已经等于0，那么直接返回false
        if (c == 0)
            return false;
            
 		// 将state-1
        int nextc = c-1;
        
        // CAS操作修改state，也就是将state原子性减一
        // 如果nextc也就是当前修改过的state已经为0了，就会返回true，也就意味着之前调用await()方法被阻塞进入AQS队列的线程可以被激活了
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

2.CyclicBarrier

2.1 什么是CyclicBarrier

从字面理解，CyclicBarrier就是回环屏障的意思，它可以让一组线程达到一个状态后再同时执行。

回环的意思是在所有线程执行完毕以后，会重置CyclicBarrier的状态使它可以被重用
屏障的意思是线程调用await方法后都会被阻塞，这个阻塞点就被称为屏障，等到所有屏障都调用了await方法后，线程们就会冲破屏障继续向下运行

2.2 CyclicBarrier的基本使用

public class CycleBarrierTest {

    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {
        // 当计数器为0时，立即执行
        @Override
        public void run() {
            System.out.println("汇总线程：" + Thread.currentThread().getName() + " 任务合并。");
        }
    });

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 将线程A添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程A：" + Thread.currentThread().getName() + "执行任务。");
                    System.out.println("线程A：到达屏障点");
                    cyclicBarrier.await();
                    System.out.println("线程A：退出屏障点");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 将线程B添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程B：" + Thread.currentThread().getName() + "执行任务。");
                    System.out.println("线程B：到达屏障点");
                    cyclicBarrier.await();
                    System.out.println("线程B：退出屏障点");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 调用线程池的shutdown方法关闭线程池
        // 该方法会使线程池从RUNNING状态转变为SHUTDOWN状态
        // SHUTDOWN状态意味着：不再接收新的任务，但是会对任务队列中的任务进行处理
        executorService.shutdown();
    }
}

执行结果为：

线程A：pool-1-thread-1执行任务。
线程A：到达屏障点
线程B：pool-1-thread-2执行任务。
线程B：到达屏障点
汇总线程：pool-1-thread-2 任务合并。
线程B：退出屏障点
线程A：退出屏障点

上面的例子说明了多个线程之间是相互等待的，假如计数器值为N，那么随后调用 await 方法的 N–1 个线程都会因为到达屏障点而被阻塞，当第 N 个线程调用 await 后，计数器值为 0 了，这时候第 N 个线程才会发出通知唤醒前面的 N–1 个线程。也就是当全部线程都到达屏障点时才能一块继续向下执行。不过这个例子并没有体现出可重用性，不过这个其实也很好理解，就是可以反复使用，感兴趣的同学可以自己去了解一下。

2.3 CyclicBarrier原理剖析

CyclicBarrier类图

请添加图片描述

由类图可知，CyclicBarrier基于独占锁实现，本质还是基于AQS实现的。

Generation内部有一个变量broken，用来记录当前屏障是否被打破，因为内部使用重入锁保证了线程安全，所以该属性不需要使用volatile修饰
parties用来记录线程个数，意味着parties个线程调用await方法以后，才会“冲破屏障”
count一开始等于parties，每当有线程调用await方法就会减一，当count为零就意味着所有线程到达了屏障点

使用两个变量的原因就是为了达成CyclicBarrier的复用性，当count计数为0以后，会将parties重新赋值给count，从而进行复用。

public CyclicBarrier(int parties, Runnable barrierAction) {
	// 判断parties的值是否合理
    if (parties <= 0) throw new IllegalArgumentException();
    // 记录下能够打破屏障的值
    this.parties = parties;
	// 记录下还需要调用几次await()方法才能打破屏障
    this.count = parties;
    // 屏障被打破后需要执行的任务
    this.barrierCommand = barrierAction;
}

同时通过构造函数我们也可以直到，我们可以传递一个任务，而这个任务的执行时机是当所有的线程都到达屏障点以后。

await()

当线程调用await方法被阻塞，直到满足以下条件之一时就会返回：

parties个线程调用了await方法，也就是所有线程都到达了屏障点
其他线程调用了该线程的interrupt方法中断了该线程
与当前屏障点关联的Generation对象的broken标志被设置为true时

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        // 调用dowait方法阻塞当前线程，第一个参数为false表示第二个参数不生效
        return dowait(false, 0L);     
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}

public int await(long timeout, TimeUnit unit)
    throws InterruptedException,
           BrokenBarrierException,
           TimeoutException {
    // 指定timeout后会自动返回
    return dowait(true, unit.toNanos(timeout));
}

dowait()

该方法实现了CyclicBarrier的核心功能。

这里要注意，正常的await是不会出现异常的，也就是说，循环屏障会一直重复利用下去，如果出现了异常，那么就会先打破屏障再抛出异常，如果不这么做，其他已经已经因为调用了await方法而阻塞的线程继续阻塞。breakBarrier方法的意义也就在这。

private int dowait(boolean timed, long nanos)
    throws InterruptedException, BrokenBarrierException,
           TimeoutException {
           
    // 获得锁并进行加锁，保证操作的原子性
    final ReentrantLock lock = this.lock;
    lock.lock();
    
    try {
    	// 获得当前generation的状态，保证当前线程执行这个方法是合理的（在屏障已经被打破的情况下继续调用await方法就是不合理的）
        final Generation g = generation;
        
        // 判断屏障是否已经被打破，如果已经被打破就直接抛出异常
        if (g.broken)
            throw new BrokenBarrierException();
            
        // 判断当前线程是否已经被标记为中断，如果已经标记为中断就要停止现在的操作！    
        if (Thread.interrupted()) {
            breakBarrier();
            throw new InterruptedException();
        }
        
        // count是还需要调用多少次await()才打破屏障的值
        // 如果index=0就说明所有的线程都到达了屏障点（也就是屏障可以被打破），此时开始执行初始化传递的任务barrierAction
        int index = --count;
        if (index == 0) { 
            boolean ranAction = false;
            try {
            	// barrierCommand是初始化时传入的一个线程，这个线程将会在count为0（屏障被打破）的时候执行
                final Runnable command = barrierCommand;
                // 执行任务
                if (command != null)
                    command.run();
                    
                ranAction = true;
                // 激活其他因调用await阻塞的线程，并且重置CyclicBarrier
                nextGeneration();
                return 0;
                
            } finally {
                if (!ranAction)
                	// 将当前屏障生成设置为已破坏并唤醒所有人
                    breakBarrier();
            }
        }
        
        // 如果index!=0
        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 {
                	// 如果出现异常，并且屏障已经被打破，那么只需要终止当前线程即可
                    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();
    }
}

// 进入下一次屏障循环
// 看到这里你应该就明白了为什么CyclicBarrier可以被复用
private void nextGeneration() {
    // 唤醒条件队列中的阻塞线程
    trip.signalAll();
    // 重置CyclicBarrier
    count = parties;
    generation = new Generation();
}

// 打破当前屏障
// 与nextGeneration()需要区别开的是，前者会将broken标识为true而后者是重新赋值一个Generation类（broken变为false）
private void breakBarrier() {
    // 标记屏障已经被打破
    generation.broken = true;
    // 将count重新设置为parties
    count = parties;
    // 唤醒条件队列中的阻塞线程
    trip.signalAll();
}

3.CountDownLatch与CyclicBarrier

CountDownLatch计数器不能重置，CyclicBarrier可以重置循环利用。
CountDownLatch是基于AQS的共享模式实现的，CyclicBarrier是基于ReentrantLock和Condition实现的。
两者最大的区别是，进行下一步动作的动作实施者是不一样的。这里的“动作实施者”有两种，一种是主线程（即执行main函数），另一种是执行任务的其他线程，后面叫这种线程为“其他线程”，区分于主线程。对于CountDownLatch，当计数为0的时候，下一步的动作实施者是main函数；对于CyclicBarrier，下一步动作实施者是“其他线程”。