import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    // 創(chuàng)建一個(gè)Semaphore實(shí)例，許可數(shù)量為3
    private static final Semaphore semaphore = new Semaphore(3);

    public static void main(String[] args) {
        // 創(chuàng)建并啟動(dòng)三個(gè)線程
        for (int i = 1; i <= 3; i++) {
            new Thread(new Task(semaphore), "線程" + i).start();
        }
    }

    static class Task implements Runnable {
        private final Semaphore semaphore;

        public Task(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                // 請(qǐng)求許可
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 獲取許可，正在執(zhí)行");
                Thread.sleep(1000); // 模擬任務(wù)執(zhí)行
                System.out.println(Thread.currentThread().getName() + " 執(zhí)行完畢，釋放許可");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 釋放許可
                semaphore.release();
            }
        }
    }
}

import java.util.concurrent.Semaphore;

public class SemaphoreDeepDive {
    public static void main(String[] args) {
        // 初始化一個(gè)只有2個(gè)許可的Semaphore
        Semaphore semaphore = new Semaphore(2);

        Runnable task = () -> {
            try {
                // 嘗試獲取許可
                semaphore.acquire();
                System.out.println("線程 " + Thread.currentThread().getName() + " 獲取了許可");
                // 模擬任務(wù)執(zhí)行
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 釋放許可
                semaphore.release();
                System.out.println("線程 " + Thread.currentThread().getName() + " 釋放了許可");
            }
        };

        // 創(chuàng)建并啟動(dòng)3個(gè)線程
        for (int i = 0; i < 3; i++) {
            new Thread(task).start();
        }
    }
}

import java.util.concurrent.Semaphore;

public class DatabaseConnectionPool {
    private final Semaphore semaphore;
    private final String[] connectionPool;
    private final boolean[] used;

    public DatabaseConnectionPool(int poolSize) {
        semaphore = new Semaphore(poolSize);
        connectionPool = new String[poolSize];
        used = new boolean[poolSize];
        for (int i = 0; i < poolSize; i++) {
            connectionPool[i] = "連接 " + (i + 1);
        }
    }

    public String getConnection() throws InterruptedException {
        semaphore.acquire();
        return getNextAvailableConnection();
    }

    public void releaseConnection(String connection) {
        if (markAsUnused(connection)) {
            semaphore.release();
        }
    }

    private synchronized String getNextAvailableConnection() {
        for (int i = 0; i < connectionPool.length; i++) {
            if (!used[i]) {
                used[i] = true;
                return connectionPool[i];
            }
        }
        return null; // 不應(yīng)該發(fā)生，semaphore保證了有可用連接
    }

    private synchronized boolean markAsUnused(String connection) {
        for (int i = 0; i < connectionPool.length; i++) {
            if (connection.equals(connectionPool[i])) {
                used[i] = false;
                return true;
            }
        }
        return false;
    }
}

import java.util.concurrent.Semaphore;

public class SemaphoreAdvancedFeatures {
    public static void main(String[] args) throws InterruptedException {
        // 創(chuàng)建一個(gè)公平模式的Semaphore
        Semaphore fairSemaphore = new Semaphore(1, true);

        // 創(chuàng)建并啟動(dòng)兩個(gè)線程
        Thread t1 = new Thread(new Worker(fairSemaphore), "線程1");
        Thread t2 = new Thread(new Worker(fairSemaphore), "線程2");
        t1.start();
        t2.start();

        // 演示可中斷操作
        Thread interruptibleThread = new Thread(() -> {
            try {
                fairSemaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 獲取了許可");
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " 被中斷");
            }
        });
        interruptibleThread.start();
        Thread.sleep(1000); // 等待一會(huì)
        interruptibleThread.interrupt(); // 中斷線程
    }

    static class Worker implements Runnable {
        private final Semaphore semaphore;

        Worker(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 獲取了許可");
                Thread.sleep(2000); // 模擬工作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                semaphore.release();
                System.out.println(Thread.currentThread().getName() + " 釋放了許可");
            }
        }
    }
}

import java.util.concurrent.Semaphore;

public class SemaphoreProblemSolving {
    private static final Semaphore semaphore = new Semaphore(1);

    public static void main(String[] args) {
        Thread thread1 = new Thread(SemaphoreProblemSolving::safeMethod, "線程1");
        Thread thread2 = new Thread(SemaphoreProblemSolving::safeMethod, "線程2");

        thread1.start();
        thread2.start();
    }

    private static void safeMethod() {
        try {
            semaphore.acquire();
            try {
                // 執(zhí)行關(guān)鍵區(qū)域代碼
                System.out.println(Thread.currentThread().getName() + " 在執(zhí)行");
                Thread.sleep(1000);
            } finally {
                semaphore.release(); // 確?？偸轻尫旁S可
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;

public class CombinedSemaphoreCountDownLatch {
    private static final int THREAD_COUNT = 5;
    private static final Semaphore semaphore = new Semaphore(2);
    private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(new Worker(i, semaphore, latch)).start();
        }
        latch.await();  // 等待所有線程完成
        System.out.println("所有線程執(zhí)行完畢");
    }

    static class Worker implements Runnable {
        private final int workerNumber;
        private final Semaphore semaphore;
        private final CountDownLatch latch;

        Worker(int workerNumber, Semaphore semaphore, CountDownLatch latch) {
            this.workerNumber = workerNumber;
            this.semaphore = semaphore;
            this.latch = latch;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人 " + workerNumber + " 正在工作");
                Thread.sleep(1000); // 模擬工作
                semaphore.release();
                latch.countDown(); // 完成工作，計(jì)數(shù)減一
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}