1. 程式人生 > >java高併發系列 - 第17天:JUC中的迴圈柵欄CyclicBarrier常見的6種使用場景及程式碼示例

java高併發系列 - 第17天:JUC中的迴圈柵欄CyclicBarrier常見的6種使用場景及程式碼示例

這是java高併發系列第17篇。

本文主要內容:

  1. 介紹CyclicBarrier
  2. 6個示例介紹CyclicBarrier的使用
  3. 對比CyclicBarrier和CountDownLatch

CyclicBarrier簡介

CyclicBarrier通常稱為迴圈屏障。它和CountDownLatch很相似,都可以使執行緒先等待然後再執行。不過CountDownLatch是使一批執行緒等待另一批執行緒執行完後再執行;而CyclicBarrier只是使等待的執行緒達到一定數目後再讓它們繼續執行。故而CyclicBarrier內部也有一個計數器,計數器的初始值在建立物件時通過構造引數指定,如下所示:

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

每呼叫一次await()方法都將使阻塞的執行緒數+1,只有阻塞的執行緒數達到設定值時屏障才會開啟,允許阻塞的所有執行緒繼續執行。除此之外,CyclicBarrier還有幾點需要注意的地方:

  • CyclicBarrier的計數器可以重置而CountDownLatch不行,這意味著CyclicBarrier例項可以被重複使用而CountDownLatch只能被使用一次。而這也是迴圈屏障迴圈二字的語義所在。
  • CyclicBarrier允許使用者自定義barrierAction操作,這是個可選操作,可以在建立CyclicBarrier物件時指定
public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}

一旦使用者在建立CyclicBarrier物件時設定了barrierAction引數,則在阻塞執行緒數達到設定值屏障開啟前,會呼叫barrierAction的run()方法完成使用者自定義的操作。

示例1:簡單使用CyclicBarrier

公司組織旅遊,大家都有經歷過,10個人,中午到飯點了,需要等到10個人都到了才能開飯,先到的人坐那等著,程式碼如下:

package com.itsoku.chat15;

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

/**
 * 微信公眾號:javacode2018,獲取年薪50萬java課程
 */
public class Demo1 {
    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);

    public static class T extends Thread {
        int sleep;

        public T(String name, int sleep) {
            super(name);
            this.sleep = sleep;
        }

        @Override
        public void run() {
            try {
                //模擬休眠
                TimeUnit.SECONDS.sleep(sleep);
                long starTime = System.currentTimeMillis();
                //呼叫await()的時候,當前執行緒將會被阻塞,需要等待其他員工都到達await了才能繼續
                cyclicBarrier.await();
                long endTime = System.currentTimeMillis();
                System.out.println(this.getName() + ",sleep:" + this.sleep + " 等待了" + (endTime - starTime) + "(ms),開始吃飯了!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            new T("員工" + i, i).start();
        }
    }
}

輸出:

員工1,sleep:1 等待了9000(ms),開始吃飯了!
員工9,sleep:9 等待了1000(ms),開始吃飯了!
員工8,sleep:8 等待了2001(ms),開始吃飯了!
員工7,sleep:7 等待了3001(ms),開始吃飯了!
員工6,sleep:6 等待了4001(ms),開始吃飯了!
員工4,sleep:4 等待了6000(ms),開始吃飯了!
員工5,sleep:5 等待了5000(ms),開始吃飯了!
員工10,sleep:10 等待了0(ms),開始吃飯了!
員工2,sleep:2 等待了7999(ms),開始吃飯了!
員工3,sleep:3 等待了7000(ms),開始吃飯了!

程式碼中模擬了10個員工上桌吃飯的場景,等待所有員工都到齊了才能開發,可以看到第10個員工最慢,前面的都在等待第10個員工,員工1等待了9秒,上面程式碼中呼叫cyclicBarrier.await();會讓當前執行緒等待。當10個員工都呼叫了cyclicBarrier.await();之後,所有處於等待中的員工都會被喚醒,然後繼續執行。

示例2:重複使用CyclicBarrier

對示例1進行改造一下,吃飯完畢之後,所有人都去車上,待所有人都到車上之後,驅車去下一景點玩。

package com.itsoku.chat15;

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

/**
 * 微信公眾號:javacode2018,獲取年薪50萬java課程
 */
public class Demo2 {
    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);

    public static class T extends Thread {
        int sleep;

        public T(String name, int sleep) {
            super(name);
            this.sleep = sleep;
        }

        //等待吃飯
        void eat() {
            try {
                //模擬休眠
                TimeUnit.SECONDS.sleep(sleep);
                long starTime = System.currentTimeMillis();
                //呼叫await()的時候,當前執行緒將會被阻塞,需要等待其他員工都到達await了才能繼續
                cyclicBarrier.await();
                long endTime = System.currentTimeMillis();
                System.out.println(this.getName() + ",sleep:" + this.sleep + " 等待了" + (endTime - starTime) + "(ms),開始吃飯了!");

                //休眠sleep時間,模擬當前員工吃飯耗時
                TimeUnit.SECONDS.sleep(sleep);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }

        //等待所有人到齊之後,開車去下一站
        void drive() {
            try {
                long starTime = System.currentTimeMillis();
                //呼叫await()的時候,當前執行緒將會被阻塞,需要等待其他員工都到達await了才能繼續
                cyclicBarrier.await();
                long endTime = System.currentTimeMillis();
                System.out.println(this.getName() + ",sleep:" + this.sleep + " 等待了" + (endTime - starTime) + "(ms),去下一景點的路上!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            //等待所有人到齊之後吃飯,先到的人坐那等著,什麼事情不要幹
            this.eat();
            //等待所有人到齊之後開車去下一景點,先到的人坐那等著,什麼事情不要幹
            this.drive();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            new T("員工" + i, i).start();
        }
    }
}

輸出:

員工10,sleep:10 等待了0(ms),開始吃飯了!
員工5,sleep:5 等待了5000(ms),開始吃飯了!
員工6,sleep:6 等待了4000(ms),開始吃飯了!
員工9,sleep:9 等待了1001(ms),開始吃飯了!
員工4,sleep:4 等待了6000(ms),開始吃飯了!
員工3,sleep:3 等待了7000(ms),開始吃飯了!
員工1,sleep:1 等待了9001(ms),開始吃飯了!
員工2,sleep:2 等待了8000(ms),開始吃飯了!
員工8,sleep:8 等待了2001(ms),開始吃飯了!
員工7,sleep:7 等待了3000(ms),開始吃飯了!
員工10,sleep:10 等待了0(ms),去下一景點的路上!
員工1,sleep:1 等待了8998(ms),去下一景點的路上!
員工5,sleep:5 等待了4999(ms),去下一景點的路上!
員工4,sleep:4 等待了5999(ms),去下一景點的路上!
員工3,sleep:3 等待了6998(ms),去下一景點的路上!
員工2,sleep:2 等待了7998(ms),去下一景點的路上!
員工9,sleep:9 等待了999(ms),去下一景點的路上!
員工8,sleep:8 等待了1999(ms),去下一景點的路上!
員工7,sleep:7 等待了2999(ms),去下一景點的路上!
員工6,sleep:6 等待了3999(ms),去下一景點的路上!

坑,又是員工10最慢,要提升效率了,不能吃的太多,得減肥。

程式碼中CyclicBarrier相當於使用了2次,第一次用於等待所有人到達後開飯,第二次用於等待所有人上車後驅車去下一景點。注意一些先到的員工會在其他人到達之前,都處於等待狀態(cyclicBarrier.await();會讓當前執行緒阻塞),無法幹其他事情,等到最後一個人到了會喚醒所有人,然後繼續。

CyclicBarrier內部相當於有個計數器(構造方法傳入的),每次呼叫await();後,計數器會減1,並且await()方法會讓當前執行緒阻塞,等待計數器減為0的時候,所有在await()上等待的執行緒被喚醒,然後繼續向下執行,此時計數器又會被還原為建立時的值,然後可以繼續再次使用。

示例3:最後到的人給大家上酒,然後開飯

還是示例1中的例子,員工10是最後到達的,讓所有人都久等了,那怎麼辦,得給所有人倒酒,然後開飯,程式碼如下:

package com.itsoku.chat15;

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

/**
 * 微信公眾號:javacode2018,獲取年薪50萬java課程
 */
public class Demo3 {
    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(10, () -> {
        //模擬倒酒,花了2秒,又得讓其他9個人等2秒
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "說,不好意思,讓大家久等了,給大家倒酒賠罪!");
    });

    public static class T extends Thread {
        int sleep;

        public T(String name, int sleep) {
            super(name);
            this.sleep = sleep;
        }

        @Override
        public void run() {
            try {
                //模擬休眠
                TimeUnit.SECONDS.sleep(sleep);
                long starTime = System.currentTimeMillis();
                //呼叫await()的時候,當前執行緒將會被阻塞,需要等待其他員工都到達await了才能繼續
                cyclicBarrier.await();
                long endTime = System.currentTimeMillis();
                System.out.println(this.getName() + ",sleep:" + this.sleep + " 等待了" + (endTime - starTime) + "(ms),開始吃飯了!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            new T("員工" + i, i).start();
        }
    }
}

輸出:

員工10說,不好意思,讓大家久等了,給大家倒酒賠罪!
員工10,sleep:10 等待了2000(ms),開始吃飯了!
員工1,sleep:1 等待了11000(ms),開始吃飯了!
員工2,sleep:2 等待了10000(ms),開始吃飯了!
員工5,sleep:5 等待了7000(ms),開始吃飯了!
員工7,sleep:7 等待了5000(ms),開始吃飯了!
員工9,sleep:9 等待了3000(ms),開始吃飯了!
員工4,sleep:4 等待了8000(ms),開始吃飯了!
員工3,sleep:3 等待了9001(ms),開始吃飯了!
員工8,sleep:8 等待了4001(ms),開始吃飯了!
員工6,sleep:6 等待了6001(ms),開始吃飯了!

程式碼中建立CyclicBarrier物件時,多傳入了一個引數(內部是倒酒操作),先到的人先等待,待所有人都到齊之後,需要先給大家倒酒,然後喚醒所有等待中的人讓大家開飯。從輸出結果中我們發現,倒酒操作是由最後一個人操作的,最後一個人倒酒完畢之後,才喚醒所有等待中的其他員工,讓大家開飯。

示例4:其中一個人等待中被打斷了

員工5等待中,突然接了個電話,有點急事,然後就拿起筷子開吃了,其他人會怎麼樣呢?看著他吃麼?

程式碼如下:

package com.itsoku.chat15;

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

/**
 * 微信公眾號:javacode2018,獲取年薪50萬java課程
 */
public class Demo4 {
    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);

    public static class T extends Thread {
        int sleep;

        public T(String name, int sleep) {
            super(name);
            this.sleep = sleep;
        }

        @Override
        public void run() {
            long starTime = 0, endTime = 0;
            try {
                //模擬休眠
                TimeUnit.SECONDS.sleep(sleep);
                starTime = System.currentTimeMillis();
                //呼叫await()的時候,當前執行緒將會被阻塞,需要等待其他員工都到達await了才能繼續
                System.out.println(this.getName() + "到了!");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            endTime = System.currentTimeMillis();
            System.out.println(this.getName() + ",sleep:" + this.sleep + " 等待了" + (endTime - starTime) + "(ms),開始吃飯了!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            int sleep = 0;
            if (i == 10) {
                sleep = 10;
            }
            T t = new T("員工" + i, sleep);
            t.start();
            if (i == 5) {
                //模擬員工5接了個電話,將自己等待吃飯給打斷了
                TimeUnit.SECONDS.sleep(1);
                System.out.println(t.getName() + ",有點急事,我先開幹了!");
                t.interrupt();
                TimeUnit.SECONDS.sleep(2);
            }
        }
    }
}

輸出:

員工4到了!
員工3到了!
員工5到了!
員工1到了!
員工2到了!
員工5,有點急事,我先開幹了!
java.util.concurrent.BrokenBarrierException
員工1,sleep:0 等待了1001(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
員工3,sleep:0 等待了1001(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
員工4,sleep:0 等待了1001(ms),開始吃飯了!
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
員工2,sleep:0 等待了1001(ms),開始吃飯了!
員工5,sleep:0 等待了1002(ms),開始吃飯了!
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
java.lang.InterruptedException
    at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(AbstractQueuedSynchronizer.java:2014)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2048)
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:234)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
java.util.concurrent.BrokenBarrierException
員工6到了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
員工9到了!
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
員工8到了!
員工7到了!
員工6,sleep:0 等待了0(ms),開始吃飯了!
員工7,sleep:0 等待了1(ms),開始吃飯了!
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
員工8,sleep:0 等待了1(ms),開始吃飯了!
員工9,sleep:0 等待了1(ms),開始吃飯了!
Disconnected from the target VM, address: '127.0.0.1:64413', transport: 'socket'
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo4$T.run(Demo4.java:31)
員工10到了!
員工10,sleep:10 等待了0(ms),開始吃飯了!

輸出的資訊看著有點亂,給大家理一理,員工5遇到急事,拿起筷子就是吃,這樣好麼,當然不好,他這麼做了,後面看他這麼做了都跟著這麼做(這種場景是不是很熟悉,有一個人拿起筷子先吃起來,其他人都跟著上了),直接不等其他人了,拿起筷子就開吃了。CyclicBarrier遇到這種情況就是這麼處理的。前面4個員工都在await()處等待著,員工5也在await()上等待著,等了1秒(TimeUnit.SECONDS.sleep(1);),接了個電話,然後給員工5傳送中斷訊號後(t.interrupt();),員工5的await()方法會觸發InterruptedException異常,此時其他等待中的前4個員工,看著5開吃了,自己立即也不等了,內部從await()方法中觸發BrokenBarrierException異常,然後也開吃了,後面的6/7/8/9/10員工來了以後發現大家都開吃了,自己也不等了,6-10員工呼叫await()直接丟擲了BrokenBarrierException異常,然後繼續向下。

結論:

  1. 內部有一個人把規則破壞了(接收到中斷訊號),其他人都不按規則來了,不會等待了
  2. 接收到中斷訊號的執行緒,await方法會觸發InterruptedException異常,然後被喚醒向下執行
  3. 其他等待中 或者後面到達的執行緒,會在await()方法上觸發BrokenBarrierException異常,然後繼續執行

示例5:其中一個人只願意等待5秒

基於示例1,員工1只願意等的5秒,5s後如果大家還沒到期,自己要開吃了,員工1開吃了,其他人會怎麼樣呢?

package com.itsoku.chat15;

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

/**
 * 微信公眾號:javacode2018,獲取年薪50萬java課程
 */
public class Demo5 {
    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);

    public static class T extends Thread {
        int sleep;

        public T(String name, int sleep) {
            super(name);
            this.sleep = sleep;
        }

        @Override
        public void run() {
            long starTime = 0, endTime = 0;
            try {
                //模擬休眠
                TimeUnit.SECONDS.sleep(sleep);
                starTime = System.currentTimeMillis();
                //呼叫await()的時候,當前執行緒將會被阻塞,需要等待其他員工都到達await了才能繼續
                System.out.println(this.getName() + "到了!");
                if (this.getName().equals("員工1")) {
                    cyclicBarrier.await(5, TimeUnit.SECONDS);
                } else {
                    cyclicBarrier.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            endTime = System.currentTimeMillis();
            System.out.println(this.getName() + ",sleep:" + this.sleep + " 等待了" + (endTime - starTime) + "(ms),開始吃飯了!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            T t = new T("員工" + i, i);
            t.start();
        }
    }
}

輸出:

員工1到了!
員工2到了!
員工3到了!
員工4到了!
員工5到了!
員工6到了!
員工1,sleep:1 等待了5001(ms),開始吃飯了!
員工5,sleep:5 等待了1001(ms),開始吃飯了!
java.util.concurrent.TimeoutException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:32)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
員工6,sleep:6 等待了2(ms),開始吃飯了!
java.util.concurrent.BrokenBarrierException
員工2,sleep:2 等待了4002(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
員工3,sleep:3 等待了3001(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
員工4,sleep:4 等待了2001(ms),開始吃飯了!
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
java.util.concurrent.BrokenBarrierException
員工7到了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
員工7,sleep:7 等待了0(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
員工8到了!
員工8,sleep:8 等待了0(ms),開始吃飯了!
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
員工9到了!
java.util.concurrent.BrokenBarrierException
員工9,sleep:9 等待了0(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)
java.util.concurrent.BrokenBarrierException
員工10到了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
員工10,sleep:10 等待了0(ms),開始吃飯了!
    at com.itsoku.chat15.Demo5$T.run(Demo5.java:34)

從輸出結果中我們可以看到:1等待5秒之後,開吃了,其他等待人都開吃了,後面來的人不等待,直接開吃了。

員工1呼叫有參await方法等待5秒之後,觸發了TimeoutException異常,然後繼續向下執行,其他的在5開吃之前已經等了一會的的幾個員工,他們看到5開吃了,自己立即不等待了,也開吃了(他們的await丟擲了BrokenBarrierException異常);還有幾個員工在5開吃之後到達的,他們直接不等待了,直接丟擲BrokenBarrierException異常,然後也開吃了。

結論:

  1. 等待超時的方法

    public int await(long timeout, TimeUnit unit) throws InterruptedException,BrokenBarrierException,TimeoutException
  2. 內部有一個人把規則破壞了(等待超時),其他人都不按規則來了,不會等待了
  3. 等待超時的執行緒,await方法會觸發TimeoutException異常,然後被喚醒向下執行
  4. 其他等待中或者後面到達的執行緒,會在await()方法上觸發BrokenBarrierException異常,然後繼續執行

示例6:重建規則

示例5中改造一下,員工1等待5秒超時之後,開吃了,打破了規則,先前等待中的以及後面到達的都不按規則來了,都拿起筷子開吃。過了一會,導遊重新告知大家,要按規則來,然後重建了規則,大家都按規則來了。

程式碼如下:

package com.itsoku.chat15;

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

/**
 * 微信公眾號:javacode2018,獲取年薪50萬java課程
 */
public class Demo6 {
    public static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);

    //規則是否已重建
    public static boolean guizhe = false;

    public static class T extends Thread {
        int sleep;

        public T(String name, int sleep) {
            super(name);
            this.sleep = sleep;
        }

        @Override
        public void run() {
            long starTime = 0, endTime = 0;
            try {
                //模擬休眠
                TimeUnit.SECONDS.sleep(sleep);
                starTime = System.currentTimeMillis();
                //呼叫await()的時候,當前執行緒將會被阻塞,需要等待其他員工都到達await了才能繼續
                System.out.println(this.getName() + "到了!");
                if (!guizhe) {
                    if (this.getName().equals("員工1")) {
                        cyclicBarrier.await(5, TimeUnit.SECONDS);
                    } else {
                        cyclicBarrier.await();
                    }
                } else {
                    cyclicBarrier.await();

                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            endTime = System.currentTimeMillis();
            System.out.println(this.getName() + ",sleep:" + this.sleep + " 等待了" + (endTime - starTime) + "(ms),開始吃飯了!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            T t = new T("員工" + i, i);
            t.start();
        }

        //等待10秒之後,重置,重建規則
        TimeUnit.SECONDS.sleep(15);
        cyclicBarrier.reset();
        guizhe = true;
        System.out.println("---------------大家太皮了,請大家按規則來------------------");
        //再來一次
        for (int i = 1; i <= 10; i++) {
            T t = new T("員工" + i, i);
            t.start();
        }
    }
}

輸出:

員工1到了!
員工2到了!
員工3到了!
員工4到了!
員工5到了!
java.util.concurrent.TimeoutException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:36)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
員工6到了!
員工1,sleep:1 等待了5002(ms),開始吃飯了!
員工6,sleep:6 等待了4(ms),開始吃飯了!
員工4,sleep:4 等待了2004(ms),開始吃飯了!
員工5,sleep:5 等待了1004(ms),開始吃飯了!
員工3,sleep:3 等待了3002(ms),開始吃飯了!
員工2,sleep:2 等待了4004(ms),開始吃飯了!
員工7到了!
員工7,sleep:7 等待了0(ms),開始吃飯了!
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
員工8到了!
員工8,sleep:8 等待了0(ms),開始吃飯了!
java.util.concurrent.BrokenBarrierException
員工9到了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
員工9,sleep:9 等待了0(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
java.util.concurrent.BrokenBarrierException
員工10到了!
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
員工10,sleep:10 等待了0(ms),開始吃飯了!
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.itsoku.chat15.Demo6$T.run(Demo6.java:38)
---------------大家太皮了,請大家按規則來------------------
員工1到了!
員工2到了!
員工3到了!
員工4到了!
員工5到了!
員工6到了!
員工7到了!
員工8到了!
員工9到了!
員工10到了!
員工10,sleep:10 等待了0(ms),開始吃飯了!
員工1,sleep:1 等待了9000(ms),開始吃飯了!
員工2,sleep:2 等待了8000(ms),開始吃飯了!
員工3,sleep:3 等待了6999(ms),開始吃飯了!
員工7,sleep:7 等待了3000(ms),開始吃飯了!
員工6,sleep:6 等待了4000(ms),開始吃飯了!
員工5,sleep:5 等待了5000(ms),開始吃飯了!
員工4,sleep:4 等待了6000(ms),開始吃飯了!
員工9,sleep:9 等待了999(ms),開始吃飯了!
員工8,sleep:8 等待了1999(ms),開始吃飯了!

第一次規則被打亂了,過了一會導遊重建了規則(cyclicBarrier.reset();),接著又重來來了一次模擬等待吃飯的操作,正常了。

CountDownLatch和CyclicBarrier的區別

還是舉例子說明一下:

CountDownLatch示例

主管相當於 CountDownLatch,幹活的小弟相當於做事情的執行緒。

老闆交給主管了一個任務,讓主管搞完之後立即上報給老闆。主管下面有10個小弟,接到任務之後將任務劃分為10個小任務分給每個小弟去幹,主管一直處於等待狀態(主管會呼叫await()方法,此方法會阻塞當前執行緒),讓每個小弟幹完之後通知一下主管(呼叫countDown()方法通知主管,此方法會立即返回),主管等到所有的小弟都做完了,會被喚醒,從await()方法上甦醒,然後將結果反饋給老闆。期間主管會等待,會等待所有小弟將結果彙報給自己。

而CyclicBarrier是一批執行緒讓自己等待,等待所有的執行緒都準備好了,自己才能繼續。

java高併發系列

  • java高併發系列 - 第1天:必須知道的幾個概念
  • java高併發系列 - 第2天:併發級別
  • java高併發系列 - 第3天:有關並行的兩個重要定律
  • java高併發系列 - 第4天:JMM相關的一些概念
  • java高併發系列 - 第5天:深入理解程序和執行緒
  • java高併發系列 - 第6天:執行緒的基本操作
  • java高併發系列 - 第7天:volatile與Java記憶體模型
  • java高併發系列 - 第8天:執行緒組
  • java高併發系列 - 第9天:使用者執行緒和守護執行緒
  • java高併發系列 - 第10天:執行緒安全和synchronized關鍵字
  • java高併發系列 - 第11天:執行緒中斷的幾種方式
  • java高併發系列 - 第12天JUC:ReentrantLock重入鎖
  • java高併發系列 - 第13天:JUC中的Condition物件
  • java高併發系列 - 第14天:JUC中的LockSupport工具類,必備技能
  • java高併發系列 - 第15天:JUC中的Semaphore(訊號量)
  • java高併發系列 - 第16天:JUC中等待多執行緒完成的工具類CountDownLatch,必備技能

高併發系列連載中,感興趣的加我微信itsoku,一起交流,關注公眾號:路人甲Java,每天獲取最新文章,送年薪50萬java學習路線視訊!

相關推薦

no