參考

• 狂神說
• JDK11文件

描述(JDK文件內容)

1. CountDownLatch 減法計數器：允許一個或多個執行緒等待直到在其他執行緒中執行的一組操作完成的同步輔助。(通過 countDow() 方法進行減少計數，當計數為0時 await 處會被喚醒)

• 構造方法 ：CountDownLatch(int count) 構造一個用給定計數初始化的 CountDownLatch
• countDown() ：減少鎖存器的計數，如果計數達到零則釋放所有等待的執行緒
• await()：導致當前執行緒等到鎖存器倒計數到零，除非執行緒是 interrupted

2. CyclicBarrier 加法計數器：一種同步輔助工具，允許一組執行緒全部等待彼此到達公共障礙點。(通過 await()
   方法進行增加計數，當計數為 parties 時執行 barrierAction 程式碼。)

• CyclicBarrier(int parties, Runnable barrierAction)：建立一個新的 CyclicBarrier ，當給定數量的參與方（執行緒）等待它時將跳閘，並且當屏障被觸發時執行給定的屏障操作，由進入屏障的最後一個執行緒執行。(有兩個構造方法，第一個構造方法可以不傳入 Runnable/Lambda，而不執行指定操作 )
• await()：等待所有 parties 在此障礙上呼叫 await 。
• reset()：將屏障重置為其初始狀態。

3. Semaphore 訊號量：計數訊號量。 從概念上講，訊號量保持一組許可。 如果有必要，每個 acquire()
   都會阻止，直到有許可證，然後接受。 每個 release() 都添加了許可證，可能會釋放阻止收購者。 但是，沒有使用實際的許可物件; Semaphore 只保留可用數量並相應地採取行動。(通過 acquire 獲取一個執行許可，當執行許可被授權完畢之後，後面還需要獲取授權的執行緒會堵塞並等待；當執行緒執行完畢後，通過 release 歸還許可。)

• Semaphore(int permits)：使用給定數量的許可和非公平公平設定建立 Semaphore 。(第二個構造方法需要傳入一個引數來設定 是否公平鎖，預設不傳入是非公平鎖)
• acquire()：從此訊號量獲取許可，阻止直到一個可用，或者執行緒為 interrupted 。
• release()：釋出許可證，將其返回到訊號量。

程式碼(狂神說程式碼)

• CountDownLatch 減法計數器

package thread;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * @Author 夏秋初
 * @Date 2022/3/1 15:36
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 減法計數器，初始化引數為設定計數次數
        CountDownLatch countDownLatch = new CountDownLatch(10);
        //
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"執行完畢");
                // 計數減一
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        // 計數器清零前不會結束
        countDownLatch.await();
        System.out.println("程式載入完畢");
    }
}

• CyclicBarrier 加法計數器

package thread;

import java.util.*;
import java.util.concurrent.*;

/**
 * @Author 夏秋初
 * @Date 2022/3/1 15:36
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 加法計數器
        CyclicBarrier cyclicBarrier = new CyclicBarrier(10, ()->{
            System.out.println("程式執行完畢");
        });
        //
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"執行完畢");
                // 計數加一
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }
}

• Semaphore 訊號量

package thread;

import java.util.*;
import java.util.concurrent.*;

/**
 * @Author 夏秋初
 * @Date 2022/3/1 15:36
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 限流
        Semaphore semaphore = new Semaphore(2);
        //
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"執行完畢");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}