玩转并发：CyclicBarrier，一不小心，你的锁就不能重用了

在这里插入图片描述

介绍

斗地主是一个非常有意思的娱乐活动，但是斗地主必须够3个人才能开始，每次凑够3个人就能开一桌。我们该如何实现这个功能呢？

也许你立马会想到CountDownLatch，CountDownLatch确实能实现这个功能，但是CountDownLatch这个共享锁只能用一次，不能循环使用，有没有可以循环使用的共享锁呢？当然有，这就是CyclicBarrier。

我们用CyclicBarrier模拟一下上面的场景

public class CyclicBarrierUseCase1 {
    
    

    public static void main(String[] args) {
    
    
        CyclicBarrier barrier = new CyclicBarrier(3);
        ExecutorService service = Executors.newCachedThreadPool();
        Random random = new Random();
        for (int i = 0; i < 6; i++) {
    
    
            int num = i;
            service.submit(() -> {
    
    
                try {
    
    
                    System.out.println(num + " 准备去棋牌馆");
                    TimeUnit.SECONDS.sleep(random.nextInt(5));
                    System.out.println(num + " 到达");
                    barrier.await();
                    System.out.println(num + " 斗地主");
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            });
        }
    }
}

输出如下，每当凑够4个人时，开始打麻将

0 准备去棋牌馆
1 准备去棋牌馆
2 准备去棋牌馆
3 准备去棋牌馆
4 准备去棋牌馆
5 准备去棋牌馆
2 到达
4 到达
5 到达
5 斗地主
2 斗地主
4 斗地主
0 到达
1 到达
3 到达
3 斗地主
0 斗地主
1 斗地主

CyclicBarrier还提供了另一个构造函数，可以让固定数量的想成到达栅栏处时，让主线程执行特定的任务

public CyclicBarrier(int parties, Runnable barrierAction) {
    
    
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}

public class CyclicBarrierUseCase2 {
    
    

    public static void main(String[] args) {
    
    
        CyclicBarrier barrier =
                new CyclicBarrier(3, () -> System.out.println("凑够人了"));
        ExecutorService service = Executors.newCachedThreadPool();
        Random random = new Random();
        for (int i = 0; i < 6; i++) {
    
    
            int num = i;
            service.submit(() -> {
    
    
                try {
    
    
                    System.out.println(num + " 准备去棋牌馆");
                    TimeUnit.SECONDS.sleep(random.nextInt(5));
                    System.out.println(num + " 到达");
                    barrier.await();
                    System.out.println(num + " 斗地主");
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            });
        }
    }
}

0 准备去棋牌馆
1 准备去棋牌馆
0 到达
2 准备去棋牌馆
3 准备去棋牌馆
3 到达
4 准备去棋牌馆
5 准备去棋牌馆
2 到达
凑够人了
2 斗地主
0 斗地主
3 斗地主
4 到达
1 到达
5 到达
凑够人了
5 斗地主
1 斗地主
4 斗地主

当凑够人的时候，让最后一个到达栅栏的线程打印一句凑够人了，各个线程再依次执行

源码

说一下类中一个重要的内部类，这个内部类只有一个属性broken，表示这个屏障被冲破了没有，如果为true，表示屏障被冲破了，此时CyclicBarrier不能正常使用，需要调用reset方法重置屏障的状态

private static class Generation {
    
    
    boolean broken = false;
}

别的成员变量大家看源码把，我就不贴了，分析一下最重要的方法await，让线程阻塞

await

public int await() throws InterruptedException, BrokenBarrierException {
    
    
    try {
    
    
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
    
    
        throw new Error(toe); // cannot happen
    }
}

也可以调用如下方法，设置阻塞的超时时间

public int await(long timeout, TimeUnit unit)
    throws InterruptedException,
           BrokenBarrierException,
           TimeoutException {
    
    
    return dowait(true, unit.toNanos(timeout));
}

可以看到最终调用的方法都是dowait，这个方法是基于ReentrantLock和Condition实现的，所以逻辑不是很复杂

private int dowait(boolean timed, long nanos)
    throws InterruptedException, BrokenBarrierException,
           TimeoutException {
    
    
    final ReentrantLock lock = this.lock;
    // 加锁，往Condition条件队列放置时，需要获取锁
    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 {
    
    
            	// 没有超时时间，阻塞当前线程
            	// 有超时时间，超时阻塞当前线程
            	// 调用await阻塞的时候会释放锁
                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.
                    // 当栅栏被重置后，发生了InterruptedException，则重置一下标记位即可
                    Thread.currentThread().interrupt();
                }
            }
			
			// 栅栏被冲破
            if (g.broken)
                throw new BrokenBarrierException();

			// 栅栏被重置了，直接return退出即可
            if (g != generation)
                return index;

			// 超时了
			// 标记栅栏被冲破，唤醒阻塞的线程
            if (timed && nanos <= 0L) {
    
    
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
    
    
        lock.unlock();
    }
}

dowait的大致流程如下

如果栅栏已经被冲破了，抛出BrokenBarrierException
如果线程被中断了，冲破栅栏，抛出InterruptedException
将count计数器减1，当计数器=0的时候，执行barrierCommand。如果正常执行，唤醒阻塞的线程，重置栅栏状态，退出。如果执行barrierCommand发生异常，则冲破栅栏
计数器不是0的时候，线程会被阻塞，当发生栅栏开放，栅栏冲破，线程中断，超时会跳出循环，此时线程接着执行

使用CyclicBarrier是一定要注意BrokenBarrierException，因为它会导致锁不能重用，需要特别注意

CyclicBarrier的克星BrokenBarrierException

BrokenBarrierException是怎么来的？

private static class Generation {
    
    
    boolean broken = false;
}

前面我们说过一个重要的成员变量broken，当broken=true的时候表示栅栏被冲破，当栅栏被冲破继续执行代码的时候，就会抛出BrokenBarrierException。

所以我们只需要找源码中broken是多会被设置为false的？

private void breakBarrier() {
    
    
    generation.broken = true;
    count = parties;
    trip.signalAll();
}

只有一个breakBarrier方法，所以调用breakBarrier的地方就是栅栏被冲破的地方，有如下5个地方

在这里插入图片描述

线程被中断
执行额外任务发生异常
发生中断唤醒线程时，当前栅栏被冲破
等待超时
把当前栅栏冲破，然后重置栅栏

我按照第3种情况举一个例子

public class MyThread extends Thread {
    
    

    private Integer num;
    private CyclicBarrier barrier;

    public MyThread(Integer num, CyclicBarrier barrier) {
    
    
        this.num = num;
        this.barrier = barrier;
    }

    @Override
    public void run() {
    
    
        try {
    
    
            Random random = new Random();
            System.out.println(num + " 准备去麻将馆");
            TimeUnit.SECONDS.sleep(random.nextInt(5));
            System.out.println(num + " 到达麻将馆");
            barrier.await();
            System.out.println(num + " 开始打");
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }
}

@Test
public void test3() throws InterruptedException {
    
    
    CyclicBarrier barrier =
            new CyclicBarrier(4, () -> System.out.println("凑够人了"));
    for (int i = 0; i < 3; i++) {
    
    
        new MyThread(i, barrier).start();
    }
    Thread thread = new MyThread(3, barrier);
    thread.start();
    TimeUnit.SECONDS.sleep(1);
    thread.interrupt();
    TimeUnit.SECONDS.sleep(5);
    for (int i = 0; i < 3; i++) {
    
    
        new MyThread(i, barrier).start();
    }
    thread = new MyThread(3, barrier);
    thread.start();
    TimeUnit.SECONDS.sleep(5);
}

输出如下
在这里插入图片描述
当一个线程被中断，会抛出InterruptedException，并且打破栅栏，线程被唤醒，然后其他线程陆续抛出BrokenBarrierException。当CyclicBarrier被持续使用时，会继续抛出BrokenBarrierException

如何处理BrokenBarrierException？

调用reset方法即可，打破现在的栅栏，重新new一个栅栏

public void reset() {
    
    
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
    
    
    	// 打破现在的栅栏
        breakBarrier();   // break the current generation
        // 重新new一个栅栏
        nextGeneration(); // start a new generation
    } finally {
    
    
        lock.unlock();
    }
}

以上面的demo为例，当第二次使用时调用reset方法即可正常使用
在这里插入图片描述

CyclicBarrier和CountDownLatch的异同

相同点

CyclicBarrier和CountDownLatch都能让一组线程达到某个条件再继续执行

不同点

作用对象不同：CyclicBarrier需要等到固定数量的线程都到达栅栏位置才能执行，作用对象是线程。而CountDownLatch只需要把state的值减少到1即可，作用对象是state值
可重用性不同：CyclicBarrier可以不断重用，而CountDownLatch只能使用一次
执行额外任务不同：CyclicBarrier当固定线程都到达栅栏处时，可以让主线程执行一个任务。而CountDownLatch则不行

参考博客

[1]https://juejin.cn/post/6844903487482904584
BrokenBarrierException异常
[2]https://zhuanlan.zhihu.com/p/148964094
好文
[3]https://blog.xujun.pro/2020/07/26/concurrent-06-cyclicbarrier%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/