多线程学习笔记-CyclicBarrier

1、CyclicBarrier的简单概述

现实生活中我们经常会遇到这样的情景，在进行某个活动前需要等待人全部都齐了才开始。例如吃饭时要等全家人都上座了才动筷子，旅游时要等全部人都到齐了才出发，比赛时要等运动员都上场后才开始。

在JUC包中为我们提供了一个同步工具类能够很好的模拟这类场景，它就是CyclicBarrier类。利用CyclicBarrier类可以实现一组线程相互等待，当所有线程都到达某个屏障点后再进行后续的操作。下图演示了这一过程。

在CyclicBarrier类的内部有一个计数器，每个线程在到达屏障点的时候都会调用await方法将自己阻塞，此时计数器会减1，当计数器减为0的时候所有因调用await方法而被阻塞的线程将被唤醒。这就是实现一组线程相互等待的原理。

public class CyclicBarrierTest {
  public static void main(String[] args) {
    final CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
      // 所有的线程到达屏障之后回调
      @Override
      public void run() {
        System.out.println("all of arrive");
      }
    });
    new Thread() {
      @Override
      public void run() {
        try {
          Thread.sleep(10000);
          System.out.println("t1 arrive");
          cyclicBarrier.await();
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }.start();

    new Thread() {
      @Override
      public void run() {
        try {
          Thread.sleep(10);
          System.out.println("t2 arrive");
          cyclicBarrier.await();
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }.start();

    try {
      System.out.println("main arrive");
      cyclicBarrier.await();
      System.out.println("发令枪打响");

    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (BrokenBarrierException e) {
      e.printStackTrace();
    }
      System.out.println(cyclicBarrier.getNumberWaiting());
      System.out.println(cyclicBarrier.getParties());
      System.out.println(cyclicBarrier.isBroken());

  }
}

reset() 将屏障重置为初始状态。如果有线程当前在屏障处等待，则它们将返回{BrokenBarrierException}。

package com.picc.concerrent3.chapter4;

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

public class CyclicBarrierTest2 {
  public static void main(String[] args) {
    final CyclicBarrier cyclicBarrier = new CyclicBarrier(2);

    new Thread(){
      @Override
      public void run() {
        try {
          TimeUnit.SECONDS.sleep(5);
          cyclicBarrier.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        } catch (BrokenBarrierException e){
          e.printStackTrace();
        }
      }
    }.start();

    new Thread(){
      @Override
      public void run() {
        try {
//          TimeUnit.SECONDS.sleep(5);
          cyclicBarrier.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        } catch (BrokenBarrierException e){
          e.printStackTrace(); // 这里抛出异常
        }
      }
    }.start();
    try {
      TimeUnit.MICROSECONDS.sleep(100);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    cyclicBarrier.reset();
  }
}

源码解析

属性描述

    /** The lock for guarding barrier entry */
    private final ReentrantLock lock = new ReentrantLock();
    // 当有线程到达时，如果count不能减到1，线程将会在该条件上等待
    private final Condition trip = lock.newCondition();
    // 表示拦截线程的总数量
    private final int parties;
    // 所有等待线程都到达时执行该命令
    private final Runnable barrierCommand;
    // 当前代
    private Generation generation = new Generation();

    // 表示拦截线程的剩余需要数量
    private int count;

在CyclicBarrier中，同一批线程属于同一代。当有 parties 个线程全部到达 barrier 时，generation 就会被更新换代。其中 broken 属性，标识该当前 CyclicBarrier 是否已经处于中断状态

    private static class Generation {
        boolean broken = false;
    }

核心方法

    private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            final Generation g = generation;
			// 当前generation“已损坏”，抛出BrokenBarrierException异常，抛出该异常一般都是某个线程在等待某个处于“断开”状态的CyclicBarrie
            if (g.broken)
                throw new BrokenBarrierException();
			// 如果线程中断，终止CyclicBarrier
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }

            int index = --count;
            // count == 0 表示所有线程均已到位，触发Runnable任务
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    if (command != null)
                    	// 触发任务
                        command.run();
                    ranAction = true;
                    // 唤醒所有等待线程，并更新generation
                    nextGeneration();
                    return 0;
                } finally {
                    if (!ranAction)
                        breakBarrier();
                }
            }
			// 对于其它（不是最后一个）线程，会在trip条件下等待
            for (;;) {
                try {
                    if (!timed)
                    	// 调用condition的await方法，加入等待队列，直到被唤醒
                        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();
				// 这一轮已经结束，则返回到达屏障的次序，0表示最后一个，parties-1表示第一个。	
                if (g != generation)
                    return index;

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

当所有线程都已经到达 barrier 处（index == 0），则会通过 nextGeneration() 方法，进行更新换代操作。在这个步骤中，做了三件事：

• 唤醒所有线程。
• 重置 count 。
• 重置 generation 。

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