共享锁,用于类似多个窗口排队买票的场景，可以同时进行多个线程的处理，超出的入队等待

    实现：

    1.   /*
    2.             业务场景：
    3.             现在又20个人排队买票，但是窗口只有三个，一个窗口一次只能让一个线程买票
    4.          */
    5.         Semaphore semaphore = new Semaphore(3);
    6.         for (int i = 0; i < 20; i++) {
    7.             new Thread(()->{
    8.                 try {
    9.                     // 加锁
    10.                     semaphore.acquire();
    11.                     System.out.println(Thread.currentThread().getName() + "正在买票");
    12.                     Thread.sleep(5000L);
    13.                     System.out.println(Thread.currentThread().getName() + "买票完成");
    14.                 } catch (InterruptedException e) {
    15.                     e.printStackTrace();
    16.                 }finally {
    17.                     // 释放
    18.                     semaphore.release();
    19.                 }
    20.             }).start();
    21.         }
    24. 输出：
    25. Thread-0正在买票
    26. Thread-1正在买票
    27. Thread-2正在买票
    28. 5S:
    30. Thread-1买票完成
    31. Thread-2买票完成
    32. Thread-3正在买票
    33. Thread-0买票完成
    34. Thread-4正在买票
    35. Thread-5正在买票
    36. ...

    上面例子中给sleep添加一个条件可以看出一个线程释放了立马就会有一个线程就执行

    1.     if(!Thread.currentThread().getName().equals("Thread-0")){
    2.         Thread.sleep(5000L);
    3.     }

    原理
    默认实现的非公平的实现方式
    image.png
    同时也能传入参数自行调整公平与非公平
    image.png
    初始化时会给state赋值，值为传入的参数，设置信号量

    加锁过程：

    1. semaphore.acquire();
    4.  public void acquire() throws InterruptedException {
    5.      sync.acquireSharedInterruptibly(1);
    6.  }
    8.  public final void acquireSharedInterruptibly(int arg)
    9.      throws InterruptedException {
    10.      if (Thread.interrupted())
    11.          throw new InterruptedException();
    12.      // tryAcquireShared中尝试加锁
    13.      if (tryAcquireShared(arg) < 0)
    14.          //    没有拿到锁就入队
    15.          doAcquireSharedInterruptibly(arg);
    16.  }
    19. // 获取资源的逻辑
    20. // acquires == 1
    21. final int nonfairTryAcquireShared(int acquires) {
    22.     for (;;) {
    23.         // 拿到现在的state
    24.         int available = getState();
    25.         // 减去传入的间隔
    26.         int remaining = available - acquires;
    27.         if (remaining < 0 ||
    28.             compareAndSetState(available, remaining)) // CAS修改
    29.             return remaining;
    30.     }
    31. }

    Semaphore在解锁的时候哟传播的特性，当先线程唤醒了修改了state的值去执行，他会判断当下线程的下一个节点的waitState是不是-1（-1代表可以被唤醒），要是等于-1就唤醒下一个线程去尝试竞争资源，不行就休眠