Java并发包中CyclicBarrier的源码分析和使用

CyclicBarrier的介绍和源码分析

CyclicBarrier的字母意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫做同步点）时被阻塞，直到最后一个线程到达屏障，屏障才会开门，所有被屏障拦截的线程才会继续干活。线程进入屏障通过CyclicBarrier的await()方法。

 

CyclicBarrier默认的构造方法是CyclicBarrier(int parties)。其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达屏障，然后当前线程被阻塞。

 

CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties，Runnable barrier Action)，用于在线程到达屏障时，优先执行barrier Action这个Runnable对象，方便处理更复杂的业务场景。

 

 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的内部定义了一个Lock对象（ReentrantLock），每当一个线程调用CyclicBarrier的await()方法时，将剩余拦截的线程数减一，然后判断剩余拦截数是否为0，如果不是，进入Lock对象的条件队列等待。如果是，执行barrierAction对象的Runnable方法，然后将所的条件队列中的所有线程放入锁等待队列中，这些线程会依次获取锁，释放锁，接着先从await()方法返回，在从CyclicBarrier的await()方法返回。

 

/** The lock for guarding barrier entry */

    private final ReentrantLock lock = new ReentrantLock();

 

await()源码：

 

public int await() throws InterruptedException, BrokenBarrierException {

        try {

            return dowait(false, 0L);

        } catch (TimeoutException toe) {

            throw new Error(toe); // cannot happen

        }

    }

dowait源码：

 

/**

     * Main barrier code, covering the various policies.

     */

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

        }

    }

 

 

 

  private void nextGeneration() {

        // signal completion of last generation

        trip.signalAll();

        // set up next generation

        count = parties;

        generation = new Generation();

    }

    /**

     * Sets current barrier generation as broken and wakes up everyone.

     * Called only while holding lock.

     */

    private void breakBarrier() {

        generation.broken = true;

        count = parties;

        trip.signalAll();

    }

 

nextGeneration和breakBarrier方法都可以停止阻塞。

CyclicBarrier主要用于一组线程之间的相互等待，而CountDownLatch一般用于一组线程等待另一组线程。实际上可以通过CountDownLatch的countDown()和await()来实现CyclicBarrier的功能。

即CountDownLatch中的countDown()和await() = CyclicBarrier中的await()。注意在一个线程中先调用countDown()再调用await()

 

CyclicBarrier对象可以重复使用，重用之前应当调用CyclicBarrier的reset方法：

 

    public void reset() {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            breakBarrier();   // break the current generation

            nextGeneration(); // start a new generation

        } finally {

            lock.unlock();

        }

    }

CyclicBarrier使用：

 

package com.fpc.Test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.Random;

public class CyclicBarrierTest {

     private CyclicBarrier cyclicBarrier = new CyclicBarrier(4);

     private Random rnd = new Random();

     

     class taskDemo implements Runnable{

           private String taskId;

           

           public taskDemo( String taskId ) {

                this.taskId = taskId;

           }

           

           @Override

           public void run() {

                try {

                     int time = rnd.nextInt(1000);

                     Thread.sleep(time);

                     System.out.println(" Thread : " + taskId + " sleep : " + time + "ms");

                     try {

                           cyclicBarrier.await();

                           System.out.println(" Thread : " + taskId + " sleep is over");

                     } catch (BrokenBarrierException e) {

                           // TODO Auto-generated catch block

                           e.printStackTrace();

                     }

                } catch (InterruptedException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

                }

           }

     }

//   CyclicBarrier cyclicBarrier = new CyclicBarrier();

     public static void main( String[] args ) {

           CyclicBarrierTest c = new CyclicBarrierTest();

           

           ExecutorService pool = Executors.newCachedThreadPool();

           pool.submit(c.new taskDemo("1"));

           pool.submit(c.new taskDemo("2"));

           pool.submit(c.new taskDemo("3"));

           pool.submit(c.new taskDemo("4"));

     }

}

运行结果：

 

 Thread : 1 sleep : 102ms

 Thread : 3 sleep : 254ms

 Thread : 4 sleep : 394ms

 Thread : 2 sleep : 943ms

 Thread : 2 sleep is over

 Thread : 1 sleep is over

 Thread : 4 sleep is over

 Thread : 3 sleep is over

 

如果构造CyclicBarrier时，给传的大小是5，但是你进入屏障的线程数只有4个，那么会发生什么现象？

这些4个线程都无法结束，因为CyclicBarrier还在等待第5个线程结束，但此时根本没有第5个线程，所以之前的4个线程根本无法结束。

 Thread : 3 sleep : 166ms

 Thread : 4 sleep : 281ms

 Thread : 2 sleep : 444ms

 Thread : 1 sleep : 776ms

那么如果构造CyclicBarrier时，给传递的参数是3呢，但此时有4个线程进入屏障呢？

结果是其中三个线程会执行然后结束，第四个线程永远无法结束，这是因为CyclicBarrier是可以循环利用的。

执行结果：

 Thread : 3 sleep : 500ms

 Thread : 1 sleep : 567ms

 Thread : 2 sleep : 912ms

 Thread : 2 sleep is over

 Thread : 3 sleep is over

 Thread : 1 sleep is over

 Thread : 4 sleep : 988ms