介绍

Semaphore，大家通常称为“信号量”。
信号量允许多个线程同时操作，后续的线程需要等待。信号量本质上是一系列许可的集合。线程需要获取到许可才可以执行，没有可用的许可，就只能等待。线程任务执行完毕后，可以归还许可给信号量。

信号量有公平和非公平两种，公平的话，则符合 First In，First out 原则，即先到先得，先到的线程可以先获得许可。

当资源有限的情况下，需要保护资源的使用时，可以使用信号量。

示例

停车场只有2个车位，来了5辆车，前面的2辆车进去后，后面的车只能等待前面的车出来，才能进去。

车

package ThreadDemo.SemaphoreDemo;
public class Car {
    private int number;
    public Car(int number){
        this.number = number;
    }
    @Override
    public String toString() {
        return "车" + this.number;
    }
}

停车场

package ThreadDemo.SemaphoreDemo;
public class ParkingSpace {
    private Car[] spaces = new Car[2];
    public void park(Car car) {
        boolean find = false;
        for (int i = 0; i < spaces.length; i++) {
            Car item = spaces[i];
            if (item == null) {
                spaces[i] = car;
                System.out.println(car.toString() + "停放在" + i);
                find=true;
                break;
            }
        }
        if(find==false)
            System.out.println(car.toString() + "没找到车位");
    }
    public void go(Car car) {
        boolean find = false;
        for (int i = 0; i < spaces.length; i++) {
            Car item = spaces[i];
            if (item == car) {
                spaces[i] = null;
                System.out.println(car.toString() + "离开了" + i);
                find =true;
                break;
            }
        }
        if(find == false)
            System.out.println(car.toString() + "没有此车");
    }
}

运行

package ThreadDemo.SemaphoreDemo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class demo02 {
    public static void main(String[] args) {
        ParkingSpace parkingSpace = new ParkingSpace();
        ExecutorService executorService = Executors.newCachedThreadPool();
        gl>Semaphore semaphore = new Semaphore(2); //一共2个许可
        for (int i=0; i<5; i++){
            int number = i+1;
            executorService.execute(() -> {
                try {
                    Car car = new Car(number);
                    gl>semaphore.acquire(); //获取许可
                    parkingSpace.park(car);
                    Thread.sleep(2000);
                    parkingSpace.go(car);
                    gl>semaphore.release(); //归还许可
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }
}

若没有上面黄色部分的代码，即没有使用信号量的话，输出的结果为

车1停放在0
车2停放在1
车3没找到车位
车4没找到车位
车5没找到车位
车1离开了0
车2离开了1
车5没有此车
车4没有此车
车3没有此车

就会发现所有的车一下子全进了停车场。为了保证只有两辆车进入，使用信号量。输出的结果为

车1停放在0
车2停放在1
车1离开了0
车2离开了1
车3停放在0
车4停放在1
车3离开了0
车5停放在0
车4离开了1
车5离开了0

这就保证了，每次只有两辆车进入。

当然上面的输出，有可能是车辆5先进去的，为了保证 先来先得，可以使用 公平信号量

Semaphore semaphore = new Semaphore(2,true);