JDK源码分析-CyclicBarrier

概述

CyclicBarrier 是并发包中的一个工具类,它的典型应用场景为:几个线程执行完任务后,执行另一个线程(回调函数,可选),然后继续下一轮,如此往复。

打个通俗的比方,可以把 CyclicBarrier 的执行流程比作:几个人(类比线程)围着操场跑圈,所有人都到达终点后(终点可理解为“屏障(barrier)”,到达次序可能有先后,对应线程执行任务有快慢),执行某个操作(回调函数),然后再继续跑下一圈(下一次循环),如此往复。

该类与 CountDownLatch 相比,可以把后者理解为“一次性(one-shot)”操作,而前者是“可循环”的操作,下面分析其代码实现。

代码分析

CyclicBarrier 的主要方法如下:

其中常用的是两个 await 方法,作用是让当前线程进入等待状态。

成员变量及嵌套类:

// 内部嵌套类
private static class Generation {
    boolean broken = false;
}

/** The lock for guarding barrier entry */
private final ReentrantLock lock = new ReentrantLock();

/** Condition to wait on until tripped */
private final Condition trip = lock.newCondition();

/** The number of parties */
private final int parties;

/* The command to run when tripped */
private final Runnable barrierCommand;

/** The current generation */
private Generation generation = new Generation();

/**
 * Number of parties still waiting. Counts down from parties to 0
 * on each generation.  It is reset to parties on each new
 * generation or when broken.
 */
private int count;

内部嵌套类 Generation 表示代数,每次屏障(barrier)破坏之前属于同一代,之后进入下一代。

构造器:

// 无回调函数
public CyclicBarrier(int parties) {
    this(parties, null);
}

// 有回调函数
public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}

CyclicBarrier 有两个构造器,其中后者可以传入一个回调函数(barrierAction),parties 表示调用 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));
}

可以看到两个 await 方法都是调用 dowait 方法来实现的(该方法也是 CyclicBarrier 的核心方法),如下:

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();
        }

        // count 减 1
        int index = --count;
        if (index == 0) {  // tripped
            // count 减到 0 时触发的操作
            boolean ranAction = false;
            try {
                // 传入的回调函数
                final Runnable command = barrierCommand;
                if (command != null)
                    // 若传了回调函数,则执行回调函数
                    // PS: 由此可知,回调函数由最后一个执行结束的线程执行
                    command.run();
                ranAction = true;
                // 进入下一代(下一轮操作)
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }

        // loop until tripped, broken, interrupted, or timed out
        for (;;) {
            try {
                // count 不为 0 时,当前线程进入等待状态
                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();
    }
}

nextGeneration 和 breakBarrier:

// 进入下一轮
private void nextGeneration() {
    // signal completion of last generation
    trip.signalAll();
    // set up next generation
    count = parties;
    generation = new Generation();
}

// 破坏屏障
private void breakBarrier() {
    generation.broken = true;
    count = parties;
    trip.signalAll();
}

执行流程:初始化时 parties 和 count 的值相同(由构造器 parties 参数传入),之后每有一个线程调用 await 方法 count 值就减 1,直至 count 为 0 时(若不为 0 则等待),执行传入的回调函数 barrierCommand(若不为空),然后唤醒所有线程,并将 count 重置为 parties,开始下一轮操作。

场景举例

为了便于理解 CyclicBarrier 的用法,下面简单举例演示(仅供参考):

public class CyclicBarrierTest {
  private static final int COUNT = 3;

  public static void main(String[] args) throws InterruptedException {
    // 初始化 CyclicBarrier 对象及回调函数
    CyclicBarrier cyclicBarrier = new CyclicBarrier(COUNT, () -> {
      // 模拟回调函数的操作(模拟写操作)
      System.out.println(Thread.currentThread().getName() + " start writing..");
      try {
        TimeUnit.SECONDS.sleep(1);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println("---------");
    });

    while (true) {
      // 创建几个线程执行任务
      for (int i = 0; i < COUNT; i++) {
        new Thread(() -> {
          // 模拟读操作
          System.out.println(Thread.currentThread().getName() + " is reading..");
          try {
            TimeUnit.SECONDS.sleep(3);
            // 等待
            cyclicBarrier.await();
          } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
          }
        }).start();
      }
      // 睡眠 10 秒,然后进入下一轮
      TimeUnit.SECONDS.sleep(10);
    }
  }
}

/*  执行结果(仅供参考):
    Thread-0 is reading..
    Thread-1 is reading..
    Thread-2 is reading..
    Thread-1 start writing..
    ---------
    Thread-3 is reading..
    Thread-4 is reading..
    Thread-5 is reading..
    Thread-5 start writing..
    ---------
*/

PS: 此处模拟多个线程执行读操作,都读完后再执行写操作;之后再读、再写……可以理解为简单的对账系统。

此处代码仅供参考,只为便于理解该类的用法。实际上每次创建线程是不合理的(可以使用线程池,由于未分析,这里暂不使用)。

小结

CyclicBarrier 也可以理解为倒数的计数器,它与 CountDownLatch 有些类似。后者是“一次性”的,而前者是“可循环使用”的

Stay hungry, stay foolish.

原文发布于微信公众号 - WriteOnRead(WriteOnRead)

原文发表时间:2019-07-05

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券