Java并发编程：CyclicBarrier可重用线程组等待同步辅助类

素颜马尾好姑娘i 2021-10-13 00:23 329阅读 0赞

原文地址：[https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html][https_docs.oracle.com_javase_7_docs_api_java_util_concurrent_CyclicBarrier.html]

java.util.concurrent中

## 类CyclicBarrier ##

*  [java.lang.Object继承][java.lang.Object]
 *  java.util.concurrent.CyclicBarrier中

* --------------------
 
  
 
 公共类CyclicBarrier 
 扩展了Object
 
 **一种同步辅助工具，允许一组线程全部等待彼此到达公共障碍点。CyclicBarriers在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。屏障称为 *循环，*因为它可以在等待线程释放后重新使用。**
 
 一的CyclicBarrier支持可选的[`Runnable`][Runnable]是每个屏障点运行一次命令，在党内的最后一个线程到达之后，但任何线程都被释放之前。在任何一方继续之前，此*屏障操作*对于更新共享状态非常有用。
 
 **示例用法：**以下是在并行分解设计中使用屏障的示例：
 
 class Solver {
 final int N;
 final float[][] data;
 final CyclicBarrier barrier;
 
 class Worker implements Runnable {
 int myRow;
 Worker(int row) { myRow = row; }
 public void run() {
 while (!done()) {
 processRow(myRow);
 
 try {
 barrier.await();
 } catch (InterruptedException ex) {
 return;
 } catch (BrokenBarrierException ex) {
 return;
 }
 }
 }
 }
 
 public Solver(float[][] matrix) {
 data = matrix;
 N = matrix.length;
 barrier = new CyclicBarrier(N,
 new Runnable() {
 public void run() {
 mergeRows(...);
 }
 });
 for (int i = 0; i < N; ++i)
 new Thread(new Worker(i)).start();
 
 waitUntilDone();
 }
 }
 
 这里，每个工作线程处理一行矩阵，然后在屏障处等待，直到所有行都被处理完毕。处理完所有行后[`Runnable`][Runnable]，将执行提供的屏障操作并合并行。如果合并确定已找到解决方案，则done（）将返回 true并且每个工作程序将终止。
 
 如果屏障操作不依赖于各方在执行时被暂停，那么该方中的任何线程都可以在释放时执行该操作。为了促进这一点，每次调用都会 [`await()`][await]返回该线程到达屏障的到达索引。然后，您可以选择应执行屏障操作的线程，例如：
 
 if（barrier.await（）== 0）{
 //记录此迭代的完成情况
 }
 
 该的CyclicBarrier使用了失败的同步尝试全或无破损模式：如果一个线程离开屏障点过早，因为中断，失败或超时，其他所有线程在该屏障点等待也将通过离开异常[`BrokenBarrierException`][BrokenBarrierException]（或者 [`InterruptedException`][InterruptedException]，如果他们也几乎在同一时间被打断了）。
 
 内存一致性效果：在调用之前的线程中的操作 `await()` [*发生在*][Link 1] 作为屏障操作一部分的操作之前，而操作又 *发生在*从`await()`其他线程中的相应成功返回*之后的*操作*之前*。
 
 **以来：**
 
 1.5
 
 **也可以看看：**
 
 [`CountDownLatch`][CountDownLatch]

* ### 方法摘要 ###
 
 <table> 
 方法&nbsp; 
 <tbody> 
 <tr> 
 <th style="text-align:left;vertical-align:top;width:429px;">修饰符和类型</th> 
 <th style="text-align:left;vertical-align:top;">方法和描述</th> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;width:446px;"><code>int</code></td> 
 <td style="text-align:left;vertical-align:top;"><code><a rel="nofollow">await</a>()</code> 等待所有<a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#getParties%28%29" rel="nofollow">各方</a>都&nbsp;在这个障碍上等待。 </td> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;width:446px;"><code>int</code></td> 
 <td style="text-align:left;vertical-align:top;"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#await%28long,%20java.util.concurrent.TimeUnit%29" rel="nofollow">await</a>(long&nbsp;timeout,&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/TimeUnit.html" rel="nofollow">TimeUnit</a>&nbsp;unit)</code> 等待所有<a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#getParties%28%29" rel="nofollow">各方</a>援引&nbsp;等待这个屏障，或指定的等待时间。 </td> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;width:446px;"><code>int</code></td> 
 <td style="text-align:left;vertical-align:top;"><code><a rel="nofollow">getNumberWaiting</a>()</code> 返回当前在屏障处等待的方数。 </td> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;width:446px;"><code>int</code></td> 
 <td style="text-align:left;vertical-align:top;"><code><a rel="nofollow">getParties</a>()</code> 返回跳过此障碍所需的参与方数量。 </td> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;width:446px;"><code>boolean</code></td> 
 <td style="text-align:left;vertical-align:top;"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#isBroken%28%29" rel="nofollow">isBroken</a>()</code> 查询此屏障是否处于损坏状态。 </td> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;width:446px;"><code>void</code></td> 
 <td style="text-align:left;vertical-align:top;"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#reset%28%29" rel="nofollow">reset</a>()</code> 将屏障重置为其初始状态。 </td> 
 </tr> 
 </tbody> 
 </table>
 
 * ### 从类java.lang继承的方法。[宾语][java.lang.Object] ###
 
 `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
 * ### 构造函数摘要 ###
 
 <table> 
 构造函数&nbsp; 
 <tbody> 
 <tr> 
 <th style="border-color:#9eadc0;text-align:left;vertical-align:top;">构造函数和描述</th> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;"><code><a rel="nofollow">CyclicBarrier</a>(int&nbsp;parties)</code> 创建一个新的CyclicBarrier，当给定数量的各方（线程）等待它时将跳闸，并且当屏障被触发时不执行预定义的操作。 </td> 
 </tr> 
 <tr> 
 <td style="text-align:left;vertical-align:top;"><code><a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#CyclicBarrier%28int,%20java.lang.Runnable%29" rel="nofollow">CyclicBarrier</a>(int&nbsp;parties,&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Runnable.html" rel="nofollow">Runnable</a>&nbsp;barrierAction)</code> 创建一个新的CyclicBarrier，当给定数量的各方（线程）正在等待它时将跳闸，并且当屏障被触发时执行给定的屏障动作，由进入屏障的最后一个线程执行。 </td> 
 </tr> 
 </tbody> 
 </table>

*  ### 方法细节 ###
    
     *  getParties
        
            public int getParties（）
        
        返回跳过此障碍所需的参与方数量。
        
        **返回：**
        
        此障碍所需的政党数量
    
     *  等待
        
            public int await（）
                      抛出InterruptedException，
                              BrokenBarrierException
        
        等待所有[各方][Link 2]都 在这个障碍上等待。
        
        如果当前线程不是最后到达的线程，那么它将被禁用以进行线程调度，并且在发生以下任何一种情况之前处于休眠状态：
        
         *  最后一个线程到了; 要么
         *  其他一些线程会[中断][Link 3] 当前线程; 要么
         *  其他一些线程会[中断][Link 3]其他 一个等待线程; 要么
         *  其他一些线程在等待屏障时超时; 要么
         *  其他一些线程[`reset()`][reset]在这个障碍上调用。
        
        如果当前线程：
        
         *  在进入此方法时设置其中断状态; 要么
         *  在等待时 被[打断][Link 3]
        
        [`InterruptedException`][InterruptedException]抛出 然后清除当前线程的中断状态。
        
        如果屏障是[`reset()`][reset]在任何线程正在等待，或者在调用await时 屏障[被破坏][Link 4]，或者在任何线程正在等待时，则 抛出该屏障。 [`BrokenBarrierException`][BrokenBarrierException]
        
        如果任何线程在等待时被[中断][Link 3]，则所有其他等待线程将抛出 [`BrokenBarrierException`][BrokenBarrierException]并且屏障处于断开状态。
        
        如果当前线程是要到达的最后一个线程，并且在构造函数中提供了非null屏障操作，则当前线程在允许其他线程继续之前运行该操作。如果在屏障操作期间发生异常，则该异常将在当前线程中传播，并且屏障处于断开状态。
        
        **返回：**
        
        当前线程的到达索引，其中index [`getParties()`][Link 2]\- 1表示第一个到达，零表示最后到达
        
        **抛出：**
        
        `InterruptedException` - 如果当前线程在等待时被中断
        
        `BrokenBarrierException`\- 如果*另一个*线程在当前线程等待时被中断或超时，或者屏障被重置，或者屏障在`await`被调用时被破坏，或者屏障操作（如果存在）因异常而失败。
    
     *  等待
        
            public int await（long timeout，
                     TimeUnit  unit）
                      抛出InterruptedException，
                              BrokenBarrierException，
                              TimeoutException
        
        等待所有[各方][Link 2]援引 等待这个屏障，或指定的等待时间。
        
        如果当前线程不是最后到达的线程，那么它将被禁用以进行线程调度，并且在发生以下任何一种情况之前处于休眠状态：
        
         *  最后一个线程到了; 要么
         *  指定的超时时间过去了; 要么
         *  其他一些线程会[中断][Link 3] 当前线程; 要么
         *  其他一些线程会[中断][Link 3]其他 一个等待线程; 要么
         *  其他一些线程在等待屏障时超时; 要么
         *  其他一些线程[`reset()`][reset]在这个障碍上调用。
        
        如果当前线程：
        
         *  在进入此方法时设置其中断状态; 要么
         *  在等待时 被[打断][Link 3]
        
        [`InterruptedException`][InterruptedException]抛出 然后清除当前线程的中断状态。
        
        如果经过指定的等待时间则[`TimeoutException`][TimeoutException] 抛出。如果时间小于或等于零，则该方法将不会等待。
        
        如果屏障是`reset()`在任何线程正在等待，或者在调用await时 屏障被破坏，或者在任何线程正在等待时，则 抛出该屏障。 [`BrokenBarrierException`][BrokenBarrierException]
        
        如果任何线程在等待时被[中断][Link 3]，则所有其他等待线程将抛出[`BrokenBarrierException`][BrokenBarrierException]并且屏障处于断开状态。
        
        如果当前线程是要到达的最后一个线程，并且在构造函数中提供了非null屏障操作，则当前线程在允许其他线程继续之前运行该操作。如果在屏障操作期间发生异常，则该异常将在当前线程中传播，并且屏障处于断开状态。
        
        **参数：**
        
        `timeout` - 等待障碍的时间
        
        `unit` - 超时参数的时间单位
        
        **返回：**
        
        当前线程的到达索引，其中index [`getParties()`][Link 2]\- 1表示第一个到达，零表示最后到达
        
        **抛出：**
        
        `InterruptedException` - 如果当前线程在等待时被中断
        
        `TimeoutException` - 如果超过指定的超时
        
        `BrokenBarrierException`\- 如果*另一个*线程在当前线程等待时被中断或超时，或者屏障被重置，或者屏幕在`await`被调用时被破坏，或者屏障操作（如果存在）因异常而失败
    
     *  被打破
        
            public boolean isBroken（）
        
        查询此屏障是否处于损坏状态。
        
        **返回：**
        
        `true`如果一方或多方因施工或上次重置导致中断或超时，或由于例外导致屏障措施失败而突破此障碍; `false`除此以外。
    
     *  重启
        
            public void reset（）
        
        将屏障重置为其初始状态。如果任何一方当前正在等待屏障，他们将返回一个 [`BrokenBarrierException`][BrokenBarrierException]。注意， 由于其他原因发生破损*后*重置可能很复杂; 线程需要以其他方式重新同步，并选择一个来执行重置。可能优选的是为随后的使用创建新的屏障。
    
     *  getNumberWaiting
        
            public int getNumberWaiting（）
        
        返回当前在屏障处等待的方数。此方法主要用于调试和断言。
        
        **返回：**
        
        目前被封锁的政党数量 [`await()`][await]
 *  ### 构造函数详细信息 ###
    
     *  的CyclicBarrier
        
            public CyclicBarrier（int parties，
                          Runnable  barrierAction）
        
        创建一个新的CyclicBarrier，当给定数量的各方（线程）正在等待它时将跳闸，并且当屏障被触发时执行给定的屏障动作，由进入屏障的最后一个线程执行。
        
        **参数：**
        
        `parties`\- 在[`await()`][await] 触发屏障之前必须调用的线程数
        
        `barrierAction`\- 屏障跳闸时执行的命令，或者`null`没有操作的命令
        
        **抛出：**
        
        `IllegalArgumentException`\- 如果`parties`小于1
    
     *  的CyclicBarrier
        
            public CyclicBarrier（int parties）
        
        创建一个新的CyclicBarrier，当给定数量的各方（线程）等待它时将跳闸，并且当屏障被触发时不执行预定义的操作。
        
        **参数：**
        
        `parties`\- 在[`await()`][await] 触发屏障之前必须调用的线程数
        
        **抛出：**
        
        `IllegalArgumentException`\- 如果`parties`小于1

[https_docs.oracle.com_javase_7_docs_api_java_util_concurrent_CyclicBarrier.html]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html
[java.lang.Object]: https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html
[Runnable]: https://docs.oracle.com/javase/7/docs/api/java/lang/Runnable.html
[await]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#await%28%29
[BrokenBarrierException]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/BrokenBarrierException.html
[InterruptedException]: https://docs.oracle.com/javase/7/docs/api/java/lang/InterruptedException.html
[Link 1]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html#MemoryVisibility
[CountDownLatch]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html
[Link 2]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#getParties%28%29
[Link 3]: https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#interrupt%28%29
[reset]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#reset%28%29
[Link 4]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#isBroken%28%29
[TimeoutException]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/TimeoutException.html