2. 程式人生 > >Java併發程式設計之CountDownLatch & CyclicBarrier

Java併發程式設計之CountDownLatch & CyclicBarrier

阿新 • • 發佈：2018-12-30

文章目錄

CountDownLatch

概述

CountDownLatch類位於java.util.concurrent包下，利用它可以實現執行緒間同步等功能。
例如，現在有一個主執行緒和兩個子執行緒，主執行緒需要等待兩個子執行緒執行結束之後才能執行，那麼就可以通過CountDownLatch來實現。

構造器 & 方法

構造器

CountDownLatch只提供了一個構造器

public CountDownLatch(int count) {
	if (count < 0) throw new IllegalArgumentException
 
("count < 0");
	this.sync = new Sync(count);
}

其中count指的是需要等待子執行緒執行的個數。例如count為2時，指的是主執行緒需要等待兩個子執行緒執行結束，才能夠繼續執行主執行緒。

方法

CountDownLatch主要有以下幾個重要方法

public void await() throws InterruptedException { };
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };
public void
 
 countDown() { };
  • await()方法 : 主執行緒呼叫await()方法，當子執行緒未完全執行結束時，主執行緒阻塞在此處。
  • await(long timeout, TimeUnit unit) : 主執行緒呼叫await(long timeout, TimeUnit unit)方法，當子執行緒未完全執行結束時，主執行緒阻塞在此處。當等待了timeout時間之後，子執行緒還是沒有執行結束，則主執行緒也不再繼續阻塞，而是繼續往下執行。
  • countDown() : 子執行緒呼叫countDown()，當子執行緒執行結束之後，呼叫這個方法，類似於計數器減一的操作，當CountDownLatch值變為0的時候，主執行緒可以繼續往下執行。

例子

此處，我們模擬一個主執行緒等待兩個子執行緒的例子:

程式碼

public class CountDownLatchDemo {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread() {
            @Override
            public void run() {
                System.out.println("子執行緒1 執行");
                System.out.println("子執行緒1 結束");
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                System.out.println("子執行緒2 執行");
                System.out.println("子執行緒2 結束");
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }
        }.start();
        System.out.println("主執行緒等待子執行緒結束");
        try {
            countDownLatch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("主執行緒 執行");
        System.out.println("主執行緒 結束");
    }
}

執行結果

子執行緒1 執行
子執行緒1 結束
子執行緒2 執行
子執行緒2 結束
主執行緒等待子執行緒結束
主執行緒 執行
主執行緒 結束

CyclicBarrier

概述

CyclicBarrier類位於java.util.concurrent包下，利用它可以實現執行緒間共同等待某個狀態，當等到這個狀態時，執行緒可以繼續往下執行，當沒有達到這個狀態時，所有執行緒阻塞。
例如，現在有一組執行緒1，2，3，4，它們共享同一個cyclicBarrier例項，只有當所有執行緒全部呼叫了cyclicBarrier的await()方法之後，這些執行緒才能夠繼續執行cyclicBarrier.await()之後的程式碼。

構造器 & 方法

構造器

CyclicBarrier提供了二個構造器

public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}

其中parties指的是需要parties個執行緒等待CyclicBarrier的狀態。barrierAction指的是CyclicBarrier達到狀態之後執行的任務。

方法

CyclicBarrier主要有以下幾個重要方法

public int await() throws InterruptedException, BrokenBarrierException {};
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException {};
  • await()方法 : 執行緒組內所有需要等待CyclicBarrier的執行緒都需要呼叫await()方法，當執行緒呼叫await()後，執行緒阻塞在此處，直到所有執行緒均呼叫了await()方法。
  • await(long timeout, TimeUnit unit) : 執行緒組內所有需要等待CyclicBarrier的執行緒都需要呼叫await()方法，當執行緒呼叫await()後，執行緒阻塞在此處，直到所有執行緒均呼叫了await()方法。當某一部分執行緒等待了timeout時間後，還是未等到CyclicBarrier達到所需的狀態，則丟擲異常，這部分執行緒繼續往下執行

例子1

此處，我們模擬一組執行緒等待某個狀態的例子:

程式碼

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        new Thread() {
            @Override
            public void run() {
                System.out.println("執行緒1 執行");
                try {
                    Thread.sleep(5000);
                    System.out.println("執行緒1 中途完成");
                    cyclicBarrier.await();
                    System.out.println("執行緒1 繼續執行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch(BrokenBarrierException e){
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                System.out.println("執行緒2 執行");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒2 中途完成");
                    cyclicBarrier.await();
                    System.out.println("執行緒2 繼續執行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch(BrokenBarrierException e){
                    e.printStackTrace();
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                System.out.println("執行緒3 執行");
                try {
                    Thread.sleep(2000);
                    System.out.println("執行緒3 中途完成");
                    cyclicBarrier.await();
                    System.out.println("執行緒3 繼續執行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch(BrokenBarrierException e){
                    e.printStackTrace();
                }
            }
        }.start();

    }
}

執行結果

執行緒1 執行
執行緒2 執行
執行緒3 執行
執行緒2 中途完成
執行緒3 中途完成
執行緒1 中途完成
執行緒1 繼續執行
執行緒2 繼續執行
執行緒3 繼續執行

例子2

此處，我們模擬一組執行緒等待某個狀態，當等到這個狀態，執行預先設定好的任務:

程式碼

public class CyclicBarrierDemo1 {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3,new Runnable() {
            @Override
            public void run() {
                System.out.println("當前執行緒" + Thread.currentThread().getName() + "繼續執行");
            }
        });
        new Thread() {
            @Override
            public void run() {
                System.out.println("執行緒1 執行");
                try {
                    Thread.sleep(5000);
                    System.out.println("執行緒1 中途完成");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch(BrokenBarrierException e){
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                System.out.println("執行緒2 執行");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒2 中途完成");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch(BrokenBarrierException e){
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                System.out.println("執行緒3 執行");
                try {
                    Thread.sleep(6000);
                    System.out.println("執行緒3 中途完成");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }catch(BrokenBarrierException e){
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

執行結果

執行緒1 執行
執行緒2 執行
執行緒3 執行
執行緒2 中途完成
執行緒1 中途完成
執行緒3 中途完成
當前執行緒Thread-2繼續執行

當三個執行緒都到達barrier狀態後，會從三個執行緒中選擇一個執行緒去執行Runnable任務。
具體是怎麼選的呢，經過測試發現，哪一個執行緒最後呼叫的cyclicBarrier.await()方法，則選取哪個執行緒執行Runnable方法。

總結

相同點

  • CountDownLatch和CyclicBarrier都能夠實現執行緒之間的等待

不同點

  • CountDownLatch一般用於某個執行緒等待若干其他執行緒執行完畢(此處的“某個執行緒”不屬於“若干個其他執行緒”)
  • CyclicBarrier一般用於一組執行緒互相等待至某個狀態，相當於這組執行緒等待它們自身達到某個狀態，而不是其他執行緒組達到某個狀態。
  • CountDownLatch是不能重用的，而CyclicBarrier是可以重用的。(本文沒有對這一點進行總結，讀者有興趣可以自己實驗)

相關推薦

Java併發程式設計之CountDownLatch &amp; CyclicBarrier

文章目錄 CountDownLatch 概述 構造器 & 方法 構造器 方法 例子 程式碼 執行結果 CyclicBarrier

Java併發程式設計之CountDownLatch、CyclicBarrier和Semaphore

在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier和Semaphore，今天我們就來學習一下這三個輔助類的用法。 CountDownLatch   CountDownLa

Java併發程式設計之CountDownLatch，CyclicBarrier實現一組執行緒相互等待、喚醒

java多執行緒應用場景不少，有時自己編寫程式碼又不太容易實現，好在concurrent包提供了不少實現類，還有google的guava包更是提供了一些最佳實踐，這讓我們在面對一些多執行緒的場景時，有了不少的選擇。這裡主要是看幾個涉及到多執行緒等待的工具類。一 CountDo

Java併發程式設計：CountDownLatch、CyclicBarrier和 Semaphore

在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier和Semaphore，今天我們就來學習一下這三個輔助類的用法。 以下是本文目錄大綱： 一.CountDownLatch用法 二.CyclicBarrier用法 三.S

14-Java併發程式設計：CountDownLatch、CyclicBarrier和Semaphore

Java併發程式設計：CountDownLatch、CyclicBarrier和Semaphore 　　在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier和Semaphore，今天我們

Java併發程式設計中CountDownLatch和CyclicBarrier的使用

在多執行緒程式設計中，經常會遇到一個執行緒等待一個或多個執行緒的場景，遇到這樣的場景應該如何解決？ 如果是一個執行緒等待一個執行緒，則可以通過await()和notify()來實現； 如果是一個執行緒等待多個執行緒，則就可以使用CountDownLatch和Cycli

Java併發程式設計：CountDownLatch、CyclicBarrier和Semaphore

一.CountDownLatch用法 　　CountDownLatch類位於java.util.concurrent包下，利用它可以實現類似計數器的功能。比如有一個任務A，它要等待其他4個任務執行完畢之後才能執行，此時就可以利用CountDownLatch來實現

Java併發程式設計之——CountDownLatch的使用

最近在開發Android專案的時候有一個需求：在Service中開啟多個執行緒併發的執行任務，當這三個執行緒執行完畢之後，主執行緒才能繼續往下執行。剛開始使用的是AsyncTask+AtomicInteger的方式，然後在onpostexecute回撥中對AtomicInte

Java併發程式設計之CountDownLatch詳解

簡介 閉鎖是一種同步工具類，可以延遲執行緒的進度，直到其到達終止狀態。閉鎖的作用相當於一扇門：在閉鎖到達結束狀態之前，這扇門一直是關閉的，並且沒有任何執行緒能夠通過，當達到結束狀態時，這扇門會開啟並允許所有的執行緒通過。當閉鎖到達結束狀態後，將不會再改變狀態，因此這扇門將永

Java併發程式設計之閉鎖CountDownLatch和柵欄(CyclicBarrier)

柵欄類似閉鎖,但是它們是有區別的. 1.閉鎖用來等待事件，而柵欄用於等待其他執行緒.什麼意思呢?就是說閉鎖用來等待的事件就是countDown事件,只有該countDown事件執行後所有之前在等待的執行緒才有可能繼續執行;而柵欄沒有類似countDown事件控

Java併發程式設計之CyclicBarrier

CyclicBarrier可以控制這樣的場景： 對多個執行緒，他們執行自己程式碼（執行run方法）的時間不一樣； 比如有3個執行緒，其run方法執行時間分別為1s, 2s, 3s。如果我們想在三個執行緒都完成自己的任務時執行相應的操作，CyclicBarrier就派上用場了。 寫了一

java併發程式設計之使用 CountDownLatch 控制多個執行緒執行順序

有時候會有這樣的需求，多個執行緒同時工作，然後其中幾個可以隨意併發執行，但有一個執行緒需要等其他執行緒工作結束後，才能開始。舉個例子，開啟多個執行緒分塊下載一個大檔案，每個執行緒只下載固定的一截，最後由另外一個執行緒來拼接所有的分段，那麼這時候我們可以考慮使用CountDownLatch來控制併發。

Java併發程式設計 之 阻塞佇列和CountDownLatch

前幾天看到一個面試題目：有一個長度為2000的字串，開三個執行緒去判斷字串中”u51”的個數。 當時看到這個題目的時候，對併發程式設計是沒有什麼經驗的，在實際專案多執行緒的應用也只有一兩次。最近在惡補《Java併發程式設計的藝術》，對這個題目就有了解題的思路了。在這裡記錄一下對該題的

實戰java高併發程式設計之CountDownLatch原始碼分析

首先看第一個！ CountDownLatch 使用場景 CountDownLatch類是常見的併發同步控制類，適用於某一執行緒的執行在其他多個執行緒執行完成之後，比如火箭發射前需要各項指標檢查，只有當各項指標檢查完才能發射，再比如解析多個excel文件，只有當

Java 併發程式設計之詳解工具類 CountDownLatch

CountDownLatch是一個在java1.5被引入同步工具類，它允許一個或多個執行緒一直等待，直到其他執行緒的操作執行完後再執行。countdownlatch在Java開發中應用場景及其廣泛，同時也是面試中的高頻考點。每一個Java程式設計師都應該熟練掌握，在本篇文章中，我將會從以下幾方面對其

Java併發程式設計之——CyclicBarrier的使用

首先看一下官方關於CyclicBarrier的簡介： /** * A synchronization aid that allows a set of threads to all wait for * each other to reach a common bar

Java例項學習 Java併發程式設計之java.util.concurrent.CountDownLatch

import java.util.concurrent.CountDownLatch; /**  * 工人類  */ class Worker {     private String name;        // 名字     private long workDuration;  // 工作持續時間  

java併發程式設計之利用CAS保證操作的原子性

import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; public class Counter { private AtomicInteger at

Java併發程式設計之鎖機制之LockSupport工具

關於文章涉及到的jdk原始碼，這裡把最新的jdk原始碼分享給大家----->jdk原始碼 前言 在上篇文章《Java併發程式設計之鎖機制之AQS(AbstractQueuedSynchronizer)》中我們瞭解了整個AQS的內部結構，與其獨佔式與共享式獲取同步狀態的實現

Java併發程式設計之執行緒生命週期、守護執行緒、優先順序和join、sleep、yield

Java併發程式設計中，其中一個難點是對執行緒生命週期的理解，和多種執行緒控制方法、執行緒溝通方法的靈活運用。這些方法和概念之間彼此聯絡緊密，共同構成了Java併發程式設計基石之一。 Java執行緒的生命週期 Java執行緒類定義了New、Runnable、Running Man、Blocked和Dead