JUC之CyclicBarrierを

簡単な紹介

CyclicBarrierを、AP Iでの同期援助はそのように説明されています。

それはお互いのために待機中のスレッドのセットが共通のバリアポイント（共通バリアポイント）に達することができます。プログラムスレッドの固定サイズのセットに関連し、これらのスレッドは、この時間CyclicBarrierを便利、随時お互いのを待たなければなりません。バリアが解除待機中のスレッドの後に再利用できるので、いわゆるサイクル（巡回）障壁（バリア）。

最後のスレッドまでのバリア到着がバリアに到達したときにスレッドのグループがブロックされている聞かせて、ドアを開けます障壁は、すべての障壁がブロックされたスレッド働き続ける：人気話すが、これがあります。

分析を実現

構造以下java.util.concurrent.CyclicBarrier：

マップによって、我々は内部CyclicBarrierをがリエントラントロックReentrantLockのと条件を使用することです見ることができます。

これは、2つのコンストラクタがあります。

1. CyclicBarrierを（パーティーint型）：新しいCyclicBarrierを作成し、それが待機状態でのパーティー（スレッド）の与えられた数で開始しますが、それはスタートアップの障壁で事前に定義されたアクションを実行しません。

2. CyclicBarrierを（int型のパーティー、RunnableをbarrierAction）：新しいCyclicBarrierを作成し、それが待機状態でのパーティー（スレッド）の与えられた数で開始し、最終によって運営されて障壁を、開始時に与えられたバリアアクションを実行しますスレッドの障壁に。

コードは以下の通りであります：

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

public CyclicBarrier(int parties) {
    this(parties, null);
}
复制代码

parties 变量，表示拦截线程的总数量。
count 变量，表示拦截线程的剩余需要数量。
barrierAction 变量，为 CyclicBarrier 接收的 Runnable 命令，用于在线程到达屏障时，优先执行 barrierAction ，用于处理更加复杂的业务场景。
generation 变量，表示 CyclicBarrier 的更新换代。详细解析，见 「2.4 Generation」 。
复制代码

待つ

各スレッドは#await（）メソッドを呼び出して、私はCyclicBarrierをを伝え、その後、現在のスレッドがブロックされ、バリアに達しています。すべてのスレッドが終了をブロックし、バリアに達した場合は、すべてのスレッドがロジックに従うことを続けることができます。

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);//不超时等待
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}
复制代码

待機をブロックし実行するための内部コール#dowait（時限ブール、長いまたはnanos）法、（=真時限）。

理論、TimeoutExceptionが異常なので、直接スローエラーエラーが発生した場合には表示されません。

the arrival index of the current thread, where index {@code getParties() - 1}
indicates the first to arrive and zero indicates the last to arrive
复制代码

待つ

タイムアウトを待っているの追加の特徴に（長いタイムアウト、TimeUnitでユニット）#awaitに基づく方法、（）を待ちます。コードは以下の通りであります：

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

待機をブロックし実行するための内部コール#dowait（時限ブール、長いまたはnanos）法、（=真時限）。

dowait

dowait（ブールタイミング、長いまたはnanos）法、次のように

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)
            //当某个线程试图等待处于断开状态的 barrier 时，或者 barrier 进入断开状态而线程处于等待状态时，抛出该异常
            throw new BrokenBarrierException();

        //如果线程中断，终止CyclicBarrier
        if (Thread.interrupted()) {
            breakBarrier();
            throw new InterruptedException();
        }

        //进来一个线程 count - 1
        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) // 未执行，说明 barrierCommand 执行报错，或者线程打断等等情况。
                    breakBarrier();
            }
        }

        for (;;) {
            try {
                //如果不是超时等待，则调用Condition.await()方法等待
                if (!timed)
                    trip.await();
                else if (nanos > 0L)
                    //超时等待，调用Condition.awaitNanos()方法等待
                    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();

            //generation已经更新，返回index
            if (g != generation)
                return index;

            //“超时等待”，并且时间已到,终止CyclicBarrier，并抛出异常
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        //释放锁
        lock.unlock();
    }
}
复制代码

スレッドが最後のスレッドが到着しない場合には、以下が発生しない限り、彼は、待機状態にされているだろう。

1. 最後のスレッドは、そのインデックス== 0になります。
2. 指定された時間を超えた（タイムアウト待ち）。
3. ほかのスレッドが現在のスレッドに割り込みます。
4. 他のスレッドが待つ別のスレッドを中断します。
5. 他のスレッドがタイムアウト障壁を待っています。
6. 他のスレッドがこのバリア#RESET（）メソッドを呼び出します。#RESET（初期状態に障壁をリセットするために使用される）の方法。

ソースコード#dowait（ブール値は、長いnanos値を時限）の方法では、我々は常に、その後、BrokenBarrierExceptionがスローされる見たときに例外を投げることができますか？例えば：

如果一个线程处于等待状态时，如果其他线程调用 #reset() 方法。
调用的 barrier 原本就是被损坏的，则抛出 BrokenBarrierException 异常。
任何线程在等待时被中断了，则其他所有线程都将抛出 BrokenBarrierException 异常，并将 barrier 置于损坏状态。
复制代码

世代

世代は、CyclicBarrierを内部の静的なクラスですCyclicBarrierをの交換を説明しています。CyclicBarrierをでは、スレッドの同じ番号が同じ世代に属しています。当事者がすべてのスレッドのバリアに到達すると、世代がアップグレードされます。壊れたプロパティは、現在のCyclicBarrierをが壊れた状態で、すでにある識別します。コードは以下の通りであります：

private static class Generation {
    boolean broken = false;
}
复制代码

デフォルトの障壁が損傷されていません。

breakBarrier

障壁が損傷し、又は中断スレッドがすべてのスレッドを終了する#breakBarrier（）メソッドを介して、そこである場合。コードは以下の通りであります：

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

breakBarrier（）メソッドでは、trueに壊れたセットに加えて、#signalAll（）メソッドを呼び出して、スレッドがCyclicBarrierをきっかけに待機状態全てになります。

次世代

場合すべてのスレッドは、次世代（）メソッド、交換作業により、意志をバリア（インデックス== 0）に達しました。このステップでは、我々は3つのことを実行します。

1. すべてのスレッドを覚まします。
2. カウント数をリセットします。
3. 世代をリセットします。

コードは以下の通りであります：

private void nextGeneration() {
    trip.signalAll();
    count = parties;
    generation = new Generation();
}
复制代码

リセット

（）メソッドは、初期状態に対するバリアリセットをリセットします。コードは以下の通りであります：

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier();   // break the current generation
        nextGeneration(); // start a new generation
    } finally {
        lock.unlock();
    }
}
复制代码

#breakBarrier（）と#nextGeneration（）メソッドの組み合わせによる。

getNumberWaiting

待機中のスレッドの数を取得するgetNumberWaiting（）メソッド。コードは以下の通りであります：

public int getNumberWaiting() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return parties - count;
    } finally {
        lock.unlock();
    }
}
复制代码

isBroken

休憩中かどうかCyclicBarrierをを決定するisBroken（）メソッド。コードは以下の通りであります：

public boolean isBroken() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return generation.broken;
    } finally {
        lock.unlock();
    }
}
复制代码

シナリオ

CyclicBarrierを、マルチスレッドデータを計算するため、マルチスレッド動作として結果を組み合わせて、シナリオの結果をマージします。例えば、我々は、Excelで複数の統計データを必要とし、その後、集計結果を待ちます。我々は、Excelのすべての和を得るために、barrierAction介してこれらのスレッドの最終結果を計算するために、対応する結果の実装が完了した後、それぞれのExcelを介してマルチスレッド処理することができます。

アプリケーション例

たとえば、私たちは次のように、会議になります出席のすべての人に会うのを待ちます。

public class CyclicBarrierTest {

    private static CyclicBarrier cyclicBarrier;

    static class CyclicBarrierThread extends Thread{
        public void run() {
            System.out.println(Thread.currentThread().getName() + "到了");
            //等待
            try {
                cyclicBarrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("人到齐了，开会吧....");
            }
        });

        for(int i = 0 ; i < 5 ; i++){
            new CyclicBarrierThread().start();
        }
    }
    
}
复制代码

結果：