刷LeetCode并发体会Semaphore

Semaphore semaphore = new Semaphore(0);
semaphore.release(3);
int i = semaphore.availablePermits();
System.out.println("i = " + i);

public class FooBySemaphore {
    public FooBySemaphore() {}
    // 先打印 one， 所以这个初始化为放行。
    private Semaphore firstPermission = new Semaphore(1);
    // 初始化 0许可，在任务的不同阶段 ‘添加许可’ 以 ‘放行线程’
    private Semaphore secondPermission = new Semaphore(0);
    private Semaphore thirdPermission = new Semaphore(0);

    public void first(Runnable printFirst) throws InterruptedException {
        firstPermission.acquire();
        printFirst.run();
        secondPermission.release(); // 放行第二个线程
    }

    public void second(Runnable printSecond) throws InterruptedException {
        secondPermission.acquire();
        printSecond.run();
        thirdPermission.release(); // 放行第三个线程
    }

    public void third(Runnable printThird) throws InterruptedException {
        thirdPermission.acquire();
        printThird.run();
        firstPermission.release(); // 放行第一个线程
    }
}

public class H2OBySemaphore {
    /**
     * 1个O原子需要2个H原子，就是说，O不能被生产直到有两个H原子被生产出来。
     *
     * 可以定义一个信号量 oSemaphore，每当一个氢原子被生产出来，就把这个信号量加1。
     * 生产出2个氢原子后oSemaphore的信号数量就是2。
     * 而生产O原子的线程需要被阻塞，直到能够 acquire 到两个信号(对应到有2个氢原子了)。
     *
     * 同样，氢原子不能被生产，直到有一个氧原子被产生出来。
     */
    public H2OBySemaphore() {
    }


    private Semaphore hPermission = new Semaphore(2); //_ 这个设置是让氢原子有优先权先生产。
    private Semaphore oPermission = new Semaphore(0); //_ 如果是把这个信号量初始化为2，就是让氧原子先生产。

    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
        hPermission.acquire();

        releaseHydrogen.run();
        oPermission.release();
    }

    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
        oPermission.acquire(2);

        releaseOxygen.run();
        hPermission.release(2);
    }
}

public class DiningPhilosophers {

    private Semaphore[] forksPermission = new Semaphore[5];

    public DiningPhilosophers() {
        for (int i = 0; i < 5; i ++) {
            forksPermission[i] = new Semaphore(1);
        }
    }

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {

        int leftFork = philosopher;
        //_ 右边的叉子编号应该比左边的小1，为了防止溢出 (5 + philosopher - 1) % 5
        int rightFork = (philosopher + 4) % 5;
        while (true) {
            // 尝试拿左叉，再拿右叉。如果同时抢左右则有死锁可能性。
            if (forksPermission[leftFork].tryAcquire()) { 
                // pickLeftFork.run(); //_ 其实应该这样更有道理，拿到左叉许可就应可执行。
                // 拿到左叉，尝试拿右叉。
                if (forksPermission[rightFork].tryAcquire()) {
                    // 左叉，右叉都拿到了。开吃！ 
                    pickLeftFork.run();
                    pickRightFork.run();
                    
                    eat.run();

                    putLeftFork.run();
                    forksPermission[leftFork].release();
                    putRightFork.run();
                    forksPermission[rightFork].release();
                    
                    break; // 吃完退出(线程)
                } else {
                    // 抢到左叉却没拿到右叉，则释放左叉给别人。自己也再重新抢。
                    forksPermission[leftFork].release();
                    Thread.sleep(1); //_ 为什么必须sleep？
                }
            } else {
                // 没抢到左叉，歇歇继续试。
                Thread.sleep(1);  //_ 为什么必须sleep？
            }
        }
    }
}