import java.util.concurrent.Semaphore;
/**
 *
 Semaphore 是一種用于控制線程并發(fā)訪問數(shù)的同步工具。它通過維護(hù)一定數(shù)量的許可證來限制對共享資源的訪問。
 許可證的數(shù)量就是可以同時訪問共享資源的線程數(shù)目。
 當(dāng)一個線程需要訪問共享資源時，它必須先獲取一個許可證，如果沒有許可證可用，線程就會被阻塞，直到有一個許可證可用。
 當(dāng)一個線程完成了對共享資源的訪問后，它必須釋放一個許可證，以便其他線程可以獲取許可證繼續(xù)訪問共享資源。
 雖然 Semaphore 主要用于限制并發(fā)訪問數(shù)，但是在實際應(yīng)用中，
 Semaphore 還可以用于線程之間的協(xié)作，比如實現(xiàn)線程的順序執(zhí)行、線程間的消息傳遞等等。
 所以，Semaphore 并不僅僅是限制并發(fā)數(shù)，它還可以用于實現(xiàn)更多的線程協(xié)作場景。
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        //availablePermits(semaphore);
        tryAcquire();
    }
    private static void tryAcquire() {
        // 創(chuàng)建一個 Semaphore 對象，初始化許可證數(shù)量為 1
        Semaphore semaphore = new Semaphore(1);
        // 獲取一個許可證，獲取成功
        boolean success1 = semaphore.tryAcquire();
        System.out.println("success1: " + success1); // 輸出 true
        // 再次獲取一個許可證，獲取失敗
        boolean success2 = semaphore.tryAcquire();
        System.out.println("success2: " + success2); // 輸出 false
        // 釋放一個許可證
        semaphore.release();
        // 再次獲取一個許可證，獲取成功
        boolean success3 = semaphore.tryAcquire();
        System.out.println("success3: " + success3); // 輸出 true
    }
    private static void availablePermits() {
        // 創(chuàng)建一個 Semaphore 對象，初始化許可證數(shù)量為 3
        Semaphore semaphore = new Semaphore(3);
        System.out.println("available permits: " + semaphore.availablePermits()); // 輸出 3
        // 獲取一個許可證
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("worker 1 is working...");
        System.out.println("available permits: " + semaphore.availablePermits()); // 輸出 2
        // 釋放一個許可證
        semaphore.release();
        System.out.println("worker 1 has finished his work.");
        System.out.println("available permits: " + semaphore.availablePermits()); // 輸出 3
    }
}

package com.lfsun.highconcurrency000.juc.semaphore;
import java.util.concurrent.Semaphore;
/**
 * 定義了一個 SemaphoreDemo 類和一個 Worker 類。SemaphoreDemo 類中創(chuàng)建了一個 Semaphore 對象，并初始化許可證數(shù)量為 3。
 * 然后，創(chuàng)建 5 個 Worker 對象，并啟動 5 個線程。
 *
 * Worker 類實現(xiàn)了 Runnable 接口，表示線程的具體工作。
 * 在 run 方法中，首先使用 acquire 方法獲取一個許可證，表示該線程需要訪問共享資源；
 * 然后，進(jìn)行一些模擬的工作，通過 sleep 方法暫停線程一段時間；最后，使用 release 方法釋放一個許可證，表示該線程已經(jīng)使用完共享資源。
 * 在輸出中可以看到，最多只有 3 個線程同時訪問共享資源。
 *
 * 需要注意的是，acquire 和 release 方法都可能拋出 InterruptedException 異常，應(yīng)該正確處理異常。
 * 另外，應(yīng)該根據(jù)實際需求調(diào)整 Semaphore 的許可證數(shù)量，以達(dá)到最優(yōu)的性能和效果。
 */
public class MySemaphoreDemo {
    public static void main(String[] args) {
        // 創(chuàng)建一個 Semaphore 對象，初始化許可證數(shù)量為 3
        Semaphore semaphore = new Semaphore(3);
        // 創(chuàng)建 5 個線程并啟動
        for (int i = 1; i <= 5; i++) {
            new Thread(new Worker(i, semaphore)).start();
        }
    }
}
class Worker implements Runnable {
    private int id;
    private Semaphore semaphore;
    public Worker(int id, Semaphore semaphore) {
        this.id = id;
        this.semaphore = semaphore;
    }
    @Override
    public void run() {
        try {
            // 獲取一個許可證
            semaphore.acquire();
            System.out.println("worker " + id + " is working...");
            // 模擬工作過程
            Thread.sleep((long) (Math.random() * 5000));
            // 釋放一個許可證
            semaphore.release();
            System.out.println("worker " + id + " has finished his work.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}