Ticket Lock, CLH Lock, MCS Lock
如果不用OS提供的mutex，我们该如何实现互斥锁？(不考虑重入的情况）
1. naive lock
最简单的想法是，搞一个volatile类型的共享变量flag，值可以是flase（无锁）或者true（有锁），竞争线程监听flag，一旦发现flag为false，那么尝试cas更新flag为true，更新成功则说明占有了这个锁，更新失败说明临界区已经被其他线程占领，继续监听flag并尝试更新。占有锁的线程退出的时候，将flag修改为false，表示释放锁。
volatile boolean flag = false; void lock() { while (!cas(flag, false, true)) {//返回true：占锁成功，返回false：占锁失败，继续循环尝试 } } void unlock() { flag = false; }
这样做有个问题是无法保证公平性，可能有的倒霉蛋空转了一辈子也无法cas成功，无法做到按竞争线程先来后到的次序占有锁。
2. Ticket Lock
为了提供公平，有人发明了Ticket Lock
线程想要竞争某个锁，需要先领一张ticket，然后监听flag，发现flag被更新为手上的ticket的值了，才能去占领锁
就像是在医院看病一样，医生就是临界区，病人就是线程，病人挂了号领一张单子，单子上写了一个独一无二的号码，病人等的时候就看屏幕，屏幕上显示到自己的号码了，才能进去找医生。
AtomicInteger ticket = new AtomicInteger(0); volatile int flag = 0; void lock() { int my_ticket = ticket.getAndIncrement();//发号必须是一个原子操作，不能多个线程拿到同一个ticket while (my_ticket != flag) { } } void unlock() { flag++; }
现在公平性的问题没有了，但是所有的线程都在监听flag变量，而且由于为了保证flag变量变化的可见性，它必须是volatile的。也就是说如果某个线程修改了flag变量，都会引起其他所有监听线程所在的core的对应于flag变量的cache line被设为invalid，那么这些线程下一次查询flag变量的时候，就必须从主存里取最新的flag数据了，由于主存带宽有限，这个开销较为昂贵（与监听线程数成正比）。
3. CLH Lock
为了减少缓存一致性带来的开销，CLH Lock被发明了。
ps，CLH实际上是指三个人：Craig, Landin, and Hagersten
CLH锁的核心思想是，1. 竞争线程排队 2. 监听变量拆分
CLH锁维护了一个链表waitingList的head与tail，其节点定义如下：
static class Node { volatile boolean flag;//true：当前线程正在试图占有锁或者已经占有锁，false：当前线程已经释放锁，下一个线程可以占有锁了 Node prev;//监听前一个节点的flag字段 }
初始时需要定义一个dummy节点（dummpy.flag == true, dummy.prev == null），head == tail == dummy
当有线程想要获取锁时，先创建一个链表节点node，然后将node挂载在waitingList的尾部（尝试cas(tail, oldTail, node)，如果成功将node.prev更新为oldTail，失败则重试）
然后这个线程就监听node.prev.flag，什么时候node.prev.flag == false了，说明node的前一个节点对应的线程已经释放了锁，本线程此时可以安全的占有锁了
释放锁的时候，将对应的node.flag修改为false即可。
实现代码如下（相当粗糙，意会即可）：
public class CLHLock { volatile Node head, tail;//waitingList public CLHLock() { head = tail = Node.DUMMY; } public Node lock() { //lock-free的将node添加到waitingList的尾部 Node node = new Node(true, null); Node oldTail = tail; while (!cas(tail, oldTail, node)) { oldTail = tail; } node.setPrev(oldTail); while (node.getPrev().isLocked()) {//监听前驱节点的locked变量 } return node; } public void unlock(Node node) { node.setLocked(false); } static class Node { public Node(boolean locked, Node prev) { this.locked = locked; this.prev = prev; } volatile boolean locked;//true：当前线程正在试图占有锁或者已经占有锁，false：当前线程已经释放锁，下一个线程可以占有锁了 Node prev;//监听前一个节点的locked字段 public boolean isLocked() { return locked; } public void setLocked(boolean locked) { this.locked = locked; } public Node getPrev() { return prev; } public void setPrev(Node prev) { this.prev = prev; } public static final Node DUMMY = new Node(false, null); } }
这样做可以极大的减少缓存一致性协议所带来的开销。
CLH锁的变种被应用于Java J.U.C包下的AbstractQueuedSynchronizer
4. MCS锁
CLH锁并不是完美的，因为每个线程都是在前驱节点的locked字段上自旋，而在NUMA体系中，有可能多个线程工作在多个不同的socket上的core里。如果前驱节点的内存跟监听线程的core距离过远，会有性能问题。
于是MCS锁诞生了
ps，MCS也是人名简写：John M. Mellor-Crummey and Michael L. Scott
MCS与CLH最大的不同在于：CLH是在前驱节点的locked域上自旋，MCS是在自己节点上的locked域上自旋。
具体的实现是，前驱节点在释放锁之后，会主动将后继节点的locked域更新。
也就是把多次对远端内存的监听 + 一次对本地内存的更新，简化成了多次对本地内存的监听 + 一次对远端内存的更新。
具体的实现如下
public class MCSLock { volatile Node head, tail;//waitingList public MCSLock() { head = tail = null; } public Node lock() { //lock-free的将node添加到waitingList的尾部 Node node = new Node(true, null); Node oldTail = tail; while (!cas(tail, oldTail, node)) { oldTail = tail; } if (null == oldTail) {//如果等待列表为空，那么获取锁成功，直接返回 return node; } oldTail.setNext(node); while (node.isLocked()) {//监听当前节点的locked变量 } return node; } public void unlock(Node node) { if (node.getNext() == null) { if (cas(tail, node, null)) {//即使当前节点的后继为null，也要用cas看一下队列是否真的为空 return; } while (node.getNext() != null) {//cas失败，说明有后继节点，只是还没更新前驱节点的next域，等前驱节点看到后继节点后，即可安全更新后继节点的locked域 } } node.getNext().setLocked(false); } static class Node { public Node(boolean locked, Node next) { this.locked = locked; this.next = next; } volatile boolean locked;//true：当前线程正在试图占有锁或者已经占有锁，false：当前线程已经释放锁，下一个线程可以占有锁了 Node next;//后继节点 public boolean isLocked() { return locked; } public void setLocked(boolean locked) { this.locked = locked; } public Node getNext() { return next; } public void setNext(Node next) { this.next = next; } }
参考资料
