2. 程式人生 > >JAVA同步屏障CyclicBarrier

JAVA同步屏障CyclicBarrier

阿新 • • 發佈：2018-11-28

一：簡單介紹同步屏障CyclicBarrier.

      1.1 CyclicBarrier可以讓一組執行緒到達一個屏障時被阻塞,直到最後一個執行緒到達屏障時,所有被屏障攔截的執行緒才會繼續向下執行的.使用場景用於多執行緒計算資料.計算結果完成,插入同步屏障,阻塞等待.

      1.2 CyclicBarrier位於java.util.concurrent包下.執行緒內執行CyclicBarrier例項物件的await()方法後此執行緒已經到達了同步屏障了,在等待其他執行緒也到達屏障吶.

      1.3 CyclicBarrier的構造方法如下.

      傳一個攔截執行緒數的引數.

    public CyclicBarrier(int parties) {
        this(parties, null);
    }

     傳一個攔截執行緒數的引數,提供一個執行緒任務,當執行緒到達屏障時,優先執行BarrierAction.

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

 二：基礎使用演示

    2.1 兩個執行緒的時候.一個主執行緒和一個自定義的子執行緒.

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
 * author:
 * date: 
 * time: 
 * description:CyclicBarrier
 * 一組執行緒到達一個屏障時被阻塞
 */
public class CyclicBarrierTest {
    private static CyclicBarrier cyclicBarrier=new CyclicBarrier(2);

        public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread執行");
            }
        }).start();
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println("Main執行");
    }
}

 執行結果如下:(多次執行後,有一下兩種結果,Java多執行緒的執行順序是CPU隨機排程的,和程式碼的物理位置的先後順序無關!)

將CyclicBarrier的攔截執行緒數目設定為3的時候.(此時任然只有一個主執行緒和一個自定義的執行緒執行).只需如下修改,其他地方不變

private static CyclicBarrier cyclicBarrier=new CyclicBarrier(3);

執行結果如下：

這個時候主執行緒和自定義的執行緒都執行了await()方法,到達了屏障,但是沒有第三個執行緒執行到屏障將不能放行此時阻塞的主執行緒個自定義執行緒了,只能等待了.

     2.2 現在執行CyclicBarrier的有優先任務的執行緒任務的.

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
 * author: 
 * date: 
 * time: 
 * description:CyclicBarrier
 * 一組執行緒到達一個屏障時被阻塞
 */
public class CyclicBarrierTest {
    private static CyclicBarrier cyclicBarrier=new CyclicBarrier(2,new ImportAction());

        public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread執行");
            }
        }).start();
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println("Main執行");
    }
}
class ImportAction implements Runnable{
    @Override
    public void run(){
        System.out.println("執行ImportAction關鍵任務");
    }
}

執行結果如下:

(首先分析一下,應該是CPU隨機排程其中一個執行緒,執行緒在其得到的時間片執行執行緒內的業務方法,然後執行了CyclicBarrier的await()方法,然後到達屏障阻塞了,在等待另外一個執行緒也到達屏障吶,但是現在有一個優先任務了,此時要執行優先執行緒任務了.).

執行完了,才會只需執行另外一個沒有到達同步屏障的任務執行緒方法.

多次執行會有以下兩種執行結果的.

下面的測試程式檢視當前CyclicBarrier阻塞的執行緒數目.

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
 * author: 
 * date: 
 * time: 
 * description:CyclicBarrier
 * 一組執行緒到達一個屏障時被阻塞
 */
public class CyclicBarrierTest {
    private static CyclicBarrier cyclicBarrier=new CyclicBarrier(2,new ImportAction());

        public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(cyclicBarrier.getParties());
                    System.out.println("此時攔截的執行緒屏障數："+ cyclicBarrier.getNumberWaiting());
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread執行");
            }
        }).start();
        System.out.println("此時攔截的執行緒屏障數："+ cyclicBarrier.getNumberWaiting());
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println("Main執行");
        System.out.println("此時攔截的執行緒屏障數："+ cyclicBarrier.getNumberWaiting());
    }
}
class ImportAction implements Runnable{
    @Override
    public void run(){
        System.out.println("執行ImportAction關鍵任務");
    }
}

執行結果：

三：實戰演練

     3.1 場景描述：一個Excel儲存了一個使用者的多個賬戶這一年內銀行消費情況,其中每個Sheet儲存了該使用者的一個賬戶一年的每一筆銀行交易消費流水詳細數目.現在要統計一下這個使用者這一年平均每天銀行消費賬目數目.（假如該使用者有四張不同銀行的銀行卡）.

    3.2 實現思路：為了計算效率,使用多執行緒分別統計出每個工作表的日均消費水平，都執行完之後就計算出了每個工作表的日均銀行消費流水數目,然後使用BarrierAction計算出所有的賬戶日均銀行消費流水賬目,繼而計算出該使用者這一年日均銀行消費流水賬目了.

    3.3 設計可能出現的問題：

         ①：如果用單執行緒計算,由於資料計算量大,效率低.

         ②：採用多執行緒,但是不使用CyclicBarrier,這裡是需要得到4個Sheet的日均流水才能得到整個使用者一年的日均銀行流水,需要等待都完成才可以的.不使用CyclicBarrier可能計算不方便,出現計算錯誤問題.

   3.4 編碼實現.

          (使用多執行緒技術羅列：CyclicBarier,ConcurrentHashMap,FixedThreadPool,Runnable.

import java.util.Map;
import java.util.concurrent.*;
/**
 * author: 
 * date: 
 * time: 
 * description:
 */
public class BankConsumeFlow implements  Runnable {
    /** 獲取當前PC的執行緒cpu數*/
    private static final Integer CPU_NUMBER=Runtime.getRuntime().availableProcessors();

    /** 設定同步屏障數目*/
    private CyclicBarrier cyclicBarrier=new CyclicBarrier(4,this);

    /** 儲存每個工作表的銀行消費日均流水*/
    private ConcurrentHashMap<String, Integer> sheetCount=new ConcurrentHashMap<>();

    /** 核心計算方法*/
    private void flowCount(){
        Executor executor= Executors.newFixedThreadPool(CPU_NUMBER);
        for(int i=0;i<CPU_NUMBER;i++){
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    // 使用常數模擬一下
                    sheetCount.put(Thread.currentThread().getName(), 100);
                    // 一個執行緒計算一個sheet完成後到達同步屏障
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        // 關閉執行緒池
        ((ExecutorService) executor).shutdown();
    }
    @Override
    public void run(){
        int result=0;
        // 統計出所有的Sheet的日均銀行消費流水
        for(Map.Entry<String,Integer> sheet:sheetCount.entrySet()){
            result+=sheet.getValue();
        }
        // 得到最後計算結果
        sheetCount.put("result", result);
        System.out.println("該使用者這一年的銀行消費日均為："+result+"元");
    }

    public static void main(String[] args) {
        BankConsumeFlow bankConsumeFlow=new BankConsumeFlow();
        bankConsumeFlow.flowCount();
    }
}

每個Sheet的計算結果為100元,4個就是400元.

四：關鍵方法總結

        3.1 getParties()：返回同步屏障攔截的執行緒數目.     

public int getParties() {
    return parties;
}

        3.2 getNumberWaiting()：返回CyclicBarrier此時正在阻塞的執行緒數目.（0~getParties()-1）    

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

  await呼叫了dowait()方法.

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

看下面這個初始化的構造方法如下.

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

 使用了ReentrantLock鎖.返回的是阻塞執行緒總數減去執行緒計數的個數就是當前正在阻塞的.

      3.3 isBoken()方法用來了解阻塞的執行緒是否被中斷了.

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

    3.4 reset()重新計算count,直接賦值為同步屏障初始化的阻塞的執行緒數.CountDownLatch的計數器只能使用一次.計算髮生錯誤可以重置計算器,執行緒重新執行一次.

private void breakBarrier() {
        generation.broken = true;
        count = parties;
        trip.signalAll();
}
public void reset() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            breakBarrier();   // break the current generation
            nextGeneration(); // start a new generation
        } finally {
            lock.unlock();
        }
 }

 

相關推薦

JAVA同步屏障CyclicBarrier

一：簡單介紹同步屏障CyclicBarrier.       1.1 CyclicBarrier可以讓一組執行緒到達一個屏障時被阻塞,直到最後一個執行緒到達屏障時,所有被屏障攔截的執行緒才會繼續向下執行的.使用場景用於多執行緒計算資料.計算結

Java併發（十三）：同步屏障CyclicBarrier

CyclicBarrier 的字面意思是可迴圈使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，屏障才會開門，所有被屏障攔截的執行緒才會繼續幹活。 一、應用舉例 public class CyclicBar

【搞定Java併發程式設計】第25篇：Java中的併發工具類之同步屏障 CyclicBarrier

上一篇：Java中的併發工具類之CountDownLatch 本文目錄： 1、CyclicBarrier的簡單概述 2、CyclicBarrier 的原始碼分析 3、CyclicBarrier與CountDownLatch的區別 1、CyclicBarrier的簡單概述

concurrent（四）同步屏障 CyclicBarrier & 源碼分析

ret https 初始 else ring class http display thread 參考文檔：Java多線程系列--“JUC鎖”10之 CyclicBarrier原理和示例：https://www.cnblogs.com/skywang12345/p/3533

併發工具類（二）同步屏障CyclicBarrier

簡介 CyclicBarrier 的字面意思是可迴圈使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，屏障才會開門，所有被屏障攔截的執行緒才會繼續幹活。CyclicBarrier預設的構造方法是Cyc

JAVA多線程提高十:同步工具CyclicBarrier與CountDownLatch

將在 con 構造方法 interrupt getc bool 區別 成績 tco 今天繼續學習其它的同步工具：CyclicBarrier與CountDownLatch 一、CyclicBarrier CyclicBarrier是一個同步輔助類，它允許一組線程互相等待，

併發：CyclicBarrier（同步屏障）。

CyclicBarrier的字面意思是可迴圈使用（Cyclic）的屏障（Barrier）。他要做的事情是，讓一組執行緒達到一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒達到屏障時，屏障才會開門，所有屏障攔截的執行緒才會繼續執行。 CyclicBarrier簡介 CyclicBarri

Java執行緒--CyclicBarrier迴圈屏障

CyclicBarrier迴圈屏障 目錄 CyclicBarrier迴圈屏障 CyclicBarrier原理  CyclicBarrier示例   CyclicBarrier和CountDownLatch區別 CyclicBarrie

CyclicBarrier - 同步屏障實現分析

CyclicBarrier CyclicBarrier 是可迴圈使用的屏障，主要功能是讓一組執行緒到達一個屏障時被阻塞，直到最後一個執行緒到達屏障時，屏障才會開啟；所有被屏障攔截的執行緒才會繼續執行。 使用示例 public class CyclicBarrierTest { //

Java併發——同步屏障

1.同步屏障 同步屏障允許一組執行緒彼此相互等待，直到抵達某個公共的屏障點。它要做的事情是，讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，屏障才會開門，所有被屏障攔截的執行緒才會繼續幹活。 舉個簡單的例子就是:旅遊團帶著一幫人蔘觀景點,規定在下一個景點A處

CyclicBarrier（同步屏障）的簡單使用

CyclicBarrer簡介 CyclicBarrer，可迴圈使用的屏障，功能是讓多個執行緒到達某個點時被阻塞，直到最後一個執行緒達到這個屏障便釋放所有執行緒，和CountDownLatch的區別即在於執行緒釋放後屏障是否可重用。 例項化：通過帶引數的new CyclicBarrer(N

Java多執行緒程式設計-（6）-兩種常用的執行緒計數器CountDownLatch和迴圈屏障CyclicBarrier

原文出自 : https://blog.csdn.net/xlgen157387/article/details/78218736 倒計時CountDownLatch CountDownLatch是一個非常實用的多執行緒控制工具類，稱之為“倒計時器”，它允許一個或多個執

二、Java多執行緒併發同步之CyclicBarrier

概述 CyclicBarrier：可迴圈屏障，允許一組執行緒全部等待的同步輔助工具。一組執行緒互相等待，直到所有執行緒都到達某個公共屏障點(也可以叫同步點) 。它可以在等待執行緒之後重新使用。這個屏障之所以用迴圈修飾，是因為在所有的執行緒釋放彼此之後，這個屏障是

死磕 java同步系列之CyclicBarrier原始碼解析——有圖有真相

問題 （1）CyclicBarrier是什麼？ （2）CyclicBarrier具有什麼特性？ （3）CyclicBarrier與

java.util.concurrent CyclicBarrier類

實現 .cn tint style pub interrupt com err rup CyclicBarrier類： 　　原文：一個同步輔助類，它允許一組線程互相等待，直到到達某個公共屏障點 (common barrier point)。在涉及一組固定大小的線程的程序中，

Java同步鎖

exce 概率 private urn 控制 art 對象 安全 這也 Java同步鎖 線程的同步是為了防止多個線程訪問一個數據對象時，對數據造成的破壞。例如：兩個線程ThreadA、ThreadB都操作同一個對象Foo對象，並修改Foo對象上的數據。 packag

Java 同步與異步-阻塞與非阻塞理解

blog markdown logs 任務 一段 mar 慢操作 兩個 需要 Java 同步與異步-阻塞與非阻塞理解 Java 中同步與異步，阻塞與非阻塞都是用來形容交互方式，區別在於它們描述的是交互的兩個不同層面。 同步與異步 同步與異步更關註交互雙方是否可以同時工作。以

Java同步(Synchronization)

對象引用 例子 修復 gif 存儲 順序 分享圖片 tutorial 意義 前言 線程間的通信主要通過共享對字段的訪問和對象引用字段的引用，可能會產生兩種錯誤，線程幹擾和內存一致性錯誤。Java的同步就是防止這些錯誤，但當多個線程訪問同一資源會導致線程執行緩慢，甚至暫停執

JAVA同步鎖機制 wait() notify() notifyAll()

使用 stack .get 不同 string java rri main cer wait() notify() notifyAll() 這3個方法用於協調多個線程對共享數據的存取，所以必須在synchronized語句塊中使用。 　　wait() 必須在synchron

Java同步—線程和進程

sta 需要 兩種 ava ted 在線 原來 java同步 同步 進程和線程 1.線程和進程的定義 進程定義：一個程序在一個數據集上的一次動態執行過程。 簡單來說： 如果把進程比喻成桌子，線程比喻成人，程序比喻成吃飯。 1.單進程單線程：一個人在一個桌子上吃飯 2.單進程