CountDownLatch（閉鎖）計數器

　　有一個任務A，它要等待其他4個任務執行完畢之後才執行，此時就可以利用CountDownLatch來實現這種功能

package com.cppdy;

import java.util.concurrent.CountDownLatch;

class MyThread17 extends Thread{
    private CountDownLatch countdownlatch;
    
    public MyThread17(CountDownLatch countdownlatch) {
        
 
this.countdownlatch=countdownlatch;
    }
    
    @Override
    public void run() {
        try {
            sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName()+"執行緒執行完畢");
        countdownlatch.countDown();
    }
}

 
public class ThreadDemo17 {

    public static void main(String[] args) throws Exception {
        CountDownLatch cd=new CountDownLatch(2);
        MyThread17 my1 = new MyThread17(cd);
        MyThread17 my2 = new MyThread17(cd);
        my1.start();
        my2.start();
        Thread.sleep(300);
        cd.await();
        System.out.println(
 
"主執行緒結束");
    }

}

CyclicBarrier（迴環柵欄）

　　CyclicBarrier初始化時規定一個數目，然後計算呼叫了CyclicBarrier.await()進入等待的執行緒數。當執行緒數達到這個數目時，所有進入等待狀態的執行緒被喚醒並繼續

package com.cppdy;

import java.util.concurrent.CyclicBarrier;

class MyThread18 extends Thread {
    private CyclicBarrier cyclicBarrier;

    public MyThread18(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        System.out.println("開始執行執行緒");
        try {
            sleep(2000);
            //第一次進來，表示有一個執行緒等待，還不滿足三個，不釋放
            //第二次進來，也不滿足
            //第三次進來，滿足了，就繼續執行下面的程式碼
            cyclicBarrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("結束執行執行緒");
    }
}

public class ThreadDemo18 {

    public static void main(String[] args) throws Exception {
        CyclicBarrier cb = new CyclicBarrier(3);
        MyThread18 my1 = new MyThread18(cb);
        MyThread18 my2 = new MyThread18(cb);
        MyThread18 my3 = new MyThread18(cb);
        my1.start();
        my2.start();
        my3.start();
        System.out.println("主執行緒執行結束");
    }

}

Semaphore（訊號量）

　　Semaphore是一種基於計數的訊號量，它可以設定一個閥值，多個執行緒競爭獲取許可訊號，做自己的申請後歸還，超過閥值後，執行緒申請許可訊號將會被阻塞

package com.cppdy;

import java.util.Random;
import java.util.concurrent.Semaphore;

class MyThread19 extends Thread {
    private String name;
    private Semaphore sp;

    public MyThread19(String name, Semaphore sp) {
        this.name = name;
        this.sp = sp;
    }

    @Override
    public void run() {
        int availablePermits = sp.availablePermits();
        if (availablePermits > 0) {
            System.out.println(name + ",好開心啊，居然還有坑");
        } else {
            System.out.println(name + ",好傷心啊，怎麼沒有坑了");
        }
        try {
            sp.acquire();
            System.out.println(name + ",好開心啊，終於搶到啦");
            //模擬上廁所時間
            Thread.sleep(new Random().nextInt(1000));
            System.out.println(name + ",好爽啊，終於上完啦");
            sp.release();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ThreadDemo19 {

    public static void main(String[] args) throws Exception {
        Semaphore sp = new Semaphore(3);
        for (int i = 0; i < 10; i++) {
            MyThread19 mt = new MyThread19("第" + i + "個人", sp);
            mt.start();
        }
    }

}