知道公司抢“坑位”是什么意思吗？

一、故事起源

很久很久以前，大概也就是昨天，肠胃作祟，急需排泄，提裤奔跑，进入厕所，

左右扫视，没有坑位，灵光一闪，换了楼层，找到坑位, 拉完粑粑接着回去写bug。

二、不安现状

身为程序员的我，想着改变世界，但遗憾暂未实现。改变一个厕所总可以吧，我不配吗？

所以我打算写一个程序来模拟厕所剩余坑位(当然了，业务上可能不会这样写，我之所以写这种代码是为了学习Semaphore，你应该懂我的良苦用心，还有就是不要给我找多线程的问题，这个示例禁不起大佬review，因为我过得浑浑噩噩。)

1. 代码先上

wc.java

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;/*** @author 发现更多精彩  关注公众号：木子的昼夜编程* 一个生活在互联网底层，做着增删改查的码农,不谙世事的造作*/
public class WC {// 假设一共有2个坑位（真少哈哈）private Semaphore s = new Semaphore(2);// 查看剩余坑位public int surplus(){// 获取剩余可用凭证数return s.availablePermits();}// 找坑位public void enter(String name){// 尝试找坑boolean b = s.tryAcquire();if (b) {System.out.println(name+"来了，有坑位，开始占用");// 模拟占用时间sleepRandom();// 释放凭证s.release();System.out.println("爽呆呆,"+name+"释放坑位");} else {System.out.println(name+"来了，木有空位，伤心离去");}}// 随机让线程睡会儿 模拟占坑时间private void sleepRandom(){try {int random=(int)(Math.random()*10+1);Thread.sleep(TimeUnit.SECONDS.toMillis(random));} catch (InterruptedException e) {e.printStackTrace();}}
}

Test.java

/*** @author 发现更多精彩  关注公众号：木子的昼夜编程* 一个生活在互联网底层，做着增删改查的码农,不谙世事的造作* @create 2021-09-19 9:25*/
public class Test {public static void main(String[] args) {WC wc = new WC();// 多个人进入厕所new Thread(()-> wc.enter("小强")).start();new Thread(()-> wc.enter("小月月")).start();new Thread(()-> wc.enter("小月鸟")).start();// 小明比较聪明 先从程序看看有没有坑位 有再去没有就不去了new Thread(()->{int sp = wc.surplus();// 如果有坑再去（但是不一定去了就有，说不定刚好别人占了呢）if (sp > 0) {wc.enter("小明");} else {System.out.println("小明知道没坑，先不去");}}).start();}
}

输出结果：

2. 理论跟上

咦？好神奇，一个Semaphore就能实现。对，就是这么牛.

这时候就有人问了，他是怎么实现这么高级的功能的，少年你是问出这个问题的时候我就知道你没有看我前边的文章（这时候可以关注：木子的昼夜编程发现更多精彩）。

他之所以这么厉害，是因为他有一个好友名字叫做：AbstractQueuedSynchronizer 用我蹩脚的英语翻译：抽象队列同步器，不重要，每个人都有小名，你可以叫他小名：AQS 。

AOS人品极好，他有很多朋友，有你熟悉的ReentrantLock、CountDownLatch 等

这里再简单介绍一下我们的兄弟AQS吧。他的主要构成有两个：state , queue

state: 记录可用凭证数（剩余坑位）

queue: 记录等待获取凭证的线程（厕所外排队拉粑粑的人）

获取坑的流程是这样的：

看着是不是很简单，判断是否有空位，有就进入，没有就排队，等待有空位再进入。

越简单的事情其实越复杂，比如为什么 1+1 = 2 。

3. 聊聊我们的 Semaphore方法

import java.util.concurrent.Semaphore;/*** @author 发现更多精彩  关注公众号：木子的昼夜编程* 一个生活在互联网底层，做着增删改查的码农,不谙世事的造作* @create 2021-09-19 10:51*/
public class TestMethod {public static void main(String[] args) throws InterruptedException {Semaphore s = new Semaphore(2);//(常用) 尝试获取凭证，直到获取到凭证或者线程被中断s.acquire();// acquire()加强版，可以一次获取多个凭证，屁股大占俩坑位s.acquire(2);// 尝试获取凭证，直到获取到凭证s.acquireUninterruptibly();// acquireUninterruptibly()的加强版 可以一次获取多个凭证s.acquireUninterruptibly(2);// 不会死等 尝试获取 获取不到就返回false 获取到就返回true// 用一个成语来形容叫：浅尝辄止boolean b = s.tryAcquire();// tryAcquire() 加强版boolean nb = s.tryAcquire(10);// 查询剩余凭证 其实就是state的值s.availablePermits();//(常用) 释放凭证 也就是离开坑位 这里需要注意，多次release 凭证会变多// 也就是release 100次 坑位就会多出100个  这个业务上需要注意，必须acquire才能release// 不然大家一看100个坑位 都去了那不打起来了吗s.release();// s.release();加强版 释放多个凭证s.release(2);// 这个方法绝了 获取所有剩余凭证并返回凭证数量// 有点儿像保洁阿姨，大喊一声：别进来了，我要开始打扫了。// drain：排水;排空;(使)流光;放干;(使)流走，流出;喝光;喝干int count = s.drainPermits();// 获取AQS的实现是否是公平模式  这个就涉及到公平、非公平了 后边再聊boolean fair = s.isFair();// 看有多少人排队int queueLength = s.getQueueLength();// 看是否还有排队的人 有就返回true 没有返回falseboolean b1 = s.hasQueuedThreads();}
}

4. AQS 对朋友的标准是什么

AQS说了，我有我的原则，你们只要遵循我的原则，我们就能成为好朋友。

原则是什么呢？AQS定义了很多方法，但是都是空实现，他的朋友们需要实现这些方法。

这不就是“模板方法”模式。

包括但不限于以下方法：

protected boolean tryAcquire(int arg) {throw new UnsupportedOperationException();
}protected boolean tryRelease(int arg) {throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int arg) {throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int arg) {throw new UnsupportedOperationException();
}

我们拿tryAcquire 举例调用链是这样的：

AQS定义了流程，朋友在遵循流程的基础上进行自我发挥就好了。

我们来看一下代码简单流程：

5.Semaphore的属性sync

sync是Semaphore属性，他可能是FairSync 也可能是NonfairSync

// AQS子类
abstract static class Sync extends AbstractQueuedSynchronizer {private static final long serialVersionUID = 1192457210091910933L;// 设置凭证 调用AQS方法Sync(int permits) {setState(permits);}// 获取凭证 调用AQS方法final int getPermits() {return getState();}// 默认实现了一个非公平的获取凭证方式// 这里大家可能有疑问，就是公平和非公平有什么不一样下边我画个图解释一下// 抢坑位final int nonfairTryAcquireShared(int acquires) {for (;;) {// 获取可用凭证数int available = getState();// 可用凭证数-申请凭证数int remaining = available - acquires;// 如果remaining小于0 也就是凭证不够// 或者cas设置state成功（获取凭证成功）// 返回剩余凭证数if (remaining < 0 ||compareAndSetState(available, remaining))return remaining;}}// 释放凭证// 蹲完坑 给别人用protected final boolean tryReleaseShared(int releases) {for (;;) {// 获取当前剩余凭证数int current = getState();// 当前凭证数+释放的凭证数int next = current + releases;// (当前凭证数+释放的凭证数) < current 可能releases是个负数 // 我没理解他为什么不直接for外边就判断releases的正负 if (next < current) // overflowthrow new Error("Maximum permit count exceeded");// 如果cas设置成功了就直接返回 否则for循环接着执行循环逻辑// for+cas 是很常用的一种乐观锁实现方式if (compareAndSetState(current, next))return true;}}// 这个可高级了 直接减掉凭证数量// 某个坑位冲水坏了，保洁直接外边立个牌子叫：禁止使用final void reducePermits(int reductions) {for (;;) {// 获取当前剩余凭证int current = getState();// 减去要削减的凭证数int next = current - reductions;// 不能大于当前凭证数// 我还是觉得在for外边判断一下reductions的正负就可以了if (next > current) // underflowthrow new Error("Permit count underflow");// casif (compareAndSetState(current, next))return;}}// 申请使用所有剩余可用凭证// 就是保洁来打扰 锁了所有没有人在使用的坑位final int drainPermits() {for (;;) {int current = getState();// cas设置为0if (current == 0 || compareAndSetState(current, 0))return current;}}
}/*** 非公平版本*/static final class NonfairSync extends Sync {private static final long serialVersionUID = -2694183684443567898L;// 调用父类构造NonfairSync(int permits) {super(permits);}// 非公平直接使用他爹 Sync的方法 protected int tryAcquireShared(int acquires) {return nonfairTryAcquireShared(acquires);}}/*** 公平版本*/static final class FairSync extends Sync {private static final long serialVersionUID = 2014338818796000944L;// 调用父类构造FairSync(int permits) {super(permits);}// 公平获取凭证的实现方式protected int tryAcquireShared(int acquires) {for (;;) {// 判断有没有人排队 有就返回-1if (hasQueuedPredecessors())return -1;// 没人排队 尝试获取凭证int available = getState();int remaining = available - acquires;if (remaining < 0 ||compareAndSetState(available, remaining))return remaining;}}}

什么是公平，什么是非公平：

我先讲个例子看大家能不能理解了。

一堆人在厕所门口排队，小强也来排队了，一看好多人排队，就乖乖的站在最后，等前边人蹲完坑了自己再去蹲，过了会儿小月鸟来了，一看厕所门口没有人排队，他就直接进去看看有没有坑，有的话就蹲，没有就算了，过了会儿小月月来了，他直接去厕所看有没有可用坑位，有的话他就占用，没有他再去后边排队。

请问他们三个人谁是公平，谁是不公平。

答案：小强、小月鸟是公平的，小月月是不公平的。

怎么区分出来的，就是他们来了有没有先看看是否有排队，如果有排队就站后边，没有人排队才能直接进去找坑位。

6. 排队是什么操作：AQS的方法之addWaiter

一直在说排队排队，是怎么排的呢，直接上代码

// 添加到队尾并返回新创建Node
final Node node = addWaiter(Node.SHARED);
// 添加到队尾
private Node addWaiter(Node mode) {// 创建一个Node Node node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failure// 获取尾结点 Node pred = tail;// 如果尾结点不是空 尝试快速把新Node追加到尾节点后边if (pred != null) {// 当前节点前一个节点设置为现在的队尾节点node.prev = pred;// cas设置node为队尾if (compareAndSetTail(pred, node)) {// 之前的队尾节点的下一个节点指向新创建的节点 这是链表添加的步骤 pred.next = node;return node;}}// 如果没有快速添加成功 就执行enq 循环添加直到成功为止enq(node);return node;
}
// 兜底循环
private Node enq(final Node node) {for (;;) {Node t = tail;// 如果tail为空 也就是链表为null 先初始化一个空节点的链表// 链表刚开始head = tail 也就是俩指针都指向空的head节点// 这个空的head节点 你一定要记住 要不然某些地方会有疑惑// 也就是说他这个队列跟排队等坑还是有区别的，最前边一个不是人// 你可以把head看成是一个排队起止线 大家都在这个线后边排队if (t == null) { // Must initializeif (compareAndSetHead(new Node()))tail = head;} else {// 追加到链表尾部 node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}
}
// cas设置头结点
private final boolean compareAndSetHead(Node update) {return unsafe.compareAndSwapObject(this, headOffset, null, update);
}// cas 设置  expect：原队尾节点   update:新创建Node
private final boolean compareAndSetTail(Node expect, Node update) {return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

7. 队列中的我们是怎么知道前边没人了呢

现实中我们可能会自己盯着，前边没人了我们自己就知道了，还有一种情况不知道大家遇到过没？

在你上学的时候，每次考完试，班主任会找那些成绩波动大的人谈话，老师谈完一个后，就会让这个人通知下一个人出去跟老师谈话，你在那惶恐不安，等着被叫。

private void doAcquireSharedInterruptibly(int arg)throws InterruptedException {// 这个是排队 前边讲了final Node node = addWaiter(Node.SHARED);boolean failed = true;try {for (;;) {// 获取当前节点的前一个节点final Node p = node.predecessor();// 看看是不是headif (p == head) {// 如果前边是head就尝试找坑int r = tryAcquireShared(arg);if (r >= 0) {// 把自己设置为头结点 并通知后边人可以找坑了setHeadAndPropagate(node, r);p.next = null; // help GCfailed = false;return;}}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())throw new InterruptedException();}} finally {if (failed)cancelAcquire(node);}
}private void setHeadAndPropagate(Node node, int propagate) {Node h = head; // Record old head for check below// 当前节点设置为头结点 setHead(node);// 符合各种条件就可以释放凭证 通知下一个人可以找坑了if (propagate > 0 || h == null || h.waitStatus < 0 ||(h = head) == null || h.waitStatus < 0) {Node s = node.next;if (s == null || s.isShared())doReleaseShared();}
}private void doReleaseShared() {for (;;) {Node h = head;// 链表不为空 并且还有后边等待的节点// 这里也是很多判断 我自己还很迷糊呢 就不瞎写了 // 大概意思就是通知后边那个人可以找坑了 if (h != null && h != tail) {int ws = h.waitStatus;if (ws == Node.SIGNAL) {if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))continue;            // loop to recheck casesunparkSuccessor(h);}else if (ws == 0 &&!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))continue;                // loop on failed CAS}if (h == head)                   // loop if head changedbreak;}}

三、还有谁

大概用到的几个点都写了写，要再细的我也没有很了解了。

更多精彩关注：木子的昼夜编程