并发之Semaphore

Semaphore，谓之信号量。信号量主要作用是允许多个线程同时访问某个资源。
构造函数如下：

public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

和重入锁一样，信号量也支持公平FairSync和非公平锁NonfairSync，也同样继承了内部类Sync,Sync也继承了AQS,之所以说AQS是JUC里的关键组件了。
信号量的使用简单，首先拿到固定数量的许可，也即声明一个对象(new Semaphore(5))，之后，基本就是通过acquire()（获取）和release()（释放）两个方法共享这个变量了。当然，和重入锁一样，信号量也提供了tryAcquire()方法，让线程在暂时拿不到许可的情况下先执行其他任务。
使用示例：

public class SemaphoreTest {
    //停车场车位
    static final class ParkCount {
        Random random = new Random();
        private Semaphore semaphore;

        public ParkCount(int count) {
            semaphore = new Semaphore(5);
        }

        //停车
        public void park(String carName) {
            try {
                semaphore.acquire();//获取锁
                int parktime = random.nextInt(10);
                System.out.println(carName + " 停车 " + parktime + "秒");
                Thread.sleep(parktime * 1000);
                semaphore.release();//释放锁
                System.out.println(carName + " 离开");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //车
    static final class Car implements Runnable {
        ParkCount parkCount;
        String carName;

        public Car(ParkCount parkCount, String carName) {
            this.parkCount = parkCount;
            this.carName = carName;
        }

        @Override
        public void run() {
            parkCount.park(carName);
        }
    }

    public static void main(String[] args) {
        ParkCount parkCount = new ParkCount(10);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 20; i++) {
            executorService.submit(new Car(parkCount,"Car"+i));
        }
    }

}

运行结果如下：

结果