【并发编程】Semaphore

Semaphore 翻译成字面意思为信号量，Semaphore 可以控制同时访问的线程个数，

通过 acquire 获取一个许可，如果没有就等待，而 release 释放一个许可。

Semaphore 类位于 java.util.concurrent 包下，它提供了 2 个构造器：

// 参数 permits 表示许可数目，即同时可以允许多少线程进行访问
public Semaphore(int permits) {}

// fair 表示是否是公平的，即等待时间越久的越先获取许可
public Semaphore(int permits, boolean fair) {}  

说一下 Semaphore 类中比较重要的几个方法，首先是 acquire、release 方法：

// 获取一个许可
public void acquire() throws InterruptedException {}

// 获取 permits 个许可
public void acquire(int permits) throws InterruptedException {} 

// 释放一个许可
public void release() {}

// 释放 permits 个许可
public void release(int permits) {} 

acquire 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。

release 用来释放许可。注意，在释放许可之前，必须先获获得许可。

这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

// 尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire() {};

// 尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) 
    throws InterruptedException {}; 

// 尝试获取 permits 个许可，若在指定的时间内获取成功，则立即返回true，否则返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) 
    throws InterruptedException {}; 

另外还可以通过 availablePermits 方法得到可用的许可数目。

应用示例：

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过 Semaphore 来实现：

public class Test {
    public static void main(String[] args) {
        // 工人数
        int N = 8;
        // 机器数目
        Semaphore semaphore = new Semaphore(5); 
        for(int i=0; i<N; i++) {
            new Worker(i, semaphore).start();
        }
    }
     
    static class Worker extends Thread {
        private int num;
        private Semaphore semaphore;
        public Worker(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }
         
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人" + this.num + "占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人" + this.num + "释放出机器");
                semaphore.release();           
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}