CLH lock is Craig, Landin, and Hagersten (CLH) locks, CLH lock is a spin lock, can ensure no hunger, provide fairness first come first service.
The CLH lock is a scalable, high performance, fairness and spin lock based on the list, the application thread spin only on a local variable, it constantly polling the precursor state, if it is found that the pre release lock end spin.
CLH(Craig, Landin, and Hagersten locks): 是一个自旋锁，能确保无饥饿性，提供先来先服务的公平性。
CLH锁也是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋。
当一个线程需要获取锁时：
创建一个的Node，将其中的locked设置为true表示需要获取锁线程对tail域调用getAndSet方法，使自己成为队列的尾部，同时获取一个指向其前趋结点的引用myPred该线程就在前趋结点的locked字段上旋转，直到前趋结点释放锁当一个线程需要释放锁时，将当前结点的locked域设置为false，同时回收前趋结点如下图，线程A需要获取锁，其myNode域为true，tail指向线程A的结点，然后线程B也加入到线程A后面，tail指向线程B的结点。然后线程A和B都在其myPred域上旋转，一旦它的myPred结点的locked字段变为false，它就可以获取锁。明显线程A的myPred locked域为false，此时线程A获取到了锁。
Java代码实现 public class ClhSpinLock implements Lock{ private final ThreadLocal<Node> prev; private final ThreadLocal<Node> node; private final AtomicReference<Node> tail = new AtomicReference<Node>(new Node()); public ClhSpinLock() { this.node = new ThreadLocal<Node>() { protected Node initialValue() { return new Node(); } }; this.prev = new ThreadLocal<Node>() { protected Node initialValue() { return null; } }; } /** * 1.初始状态 tail指向一个node(head)节点 * +------+ * | head | <---- tail * +------+ * * 2.lock-thread加入等待队列: tail指向新的Node，同时Prev指向tail之前指向的节点 * +----------+ * | Thread-A | * | := Node | <---- tail * | := Prev | -----> +------+ * +----------+ | head | * +------+ * * +----------+ +----------+ * | Thread-B | | Thread-A | * tail ----> | := Node | --> | := Node | * | := Prev | ----| | := Prev | -----> +------+ * +----------+ +----------+ | head | * +------+ * 3.寻找当前node的prev-node然后开始自旋 * */ public void lock() { final Node node = this.node.get(); node.locked = true; Node pred = this.tail.getAndSet(node); this.prev.set(pred); // 自旋 while (pred.locked); } public void unlock() { final Node node = this.node.get(); node.locked = false; this.node.set(this.prev.get()); } @Override public void lockInterruptibly() throws InterruptedException { // TODO Auto-generated method stub } @Override public boolean tryLock() { // TODO Auto-generated method stub return false; } @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { // TODO Auto-generated method stub return false; } @Override public Condition newCondition() { // TODO Auto-generated method stub return null; } private static class Node { private volatile boolean locked; }}基于链表，线程仅在一个局部变量上自旋，它不断轮询前一个节点状态，如果发现前一个节点释放锁结束.
所以在java中使用了ThreadLocal作为具体实现,AtomicReference为了消除多个线程并发对tail引用Node的影响，核心方法lock()中分为3个步骤去实现
1、初始状态 tail指向一个node(head)节点 private final AtomicReference<Node> tail = new AtomicReference<Node>(new Node()); 2、thread加入等待队列: tail指向新的Node，同时Prev指向tail之前指向的节点，在java代码中使用了getAndSet即CAS操作使用 Node pred = this.tail.getAndSet(node); this.prev.set(pred); 3、寻找当前线程对应的node的前驱node然后开始自旋前驱node的status判断是否可以获取lock while (pred.locked);同理unlock()方法，获取当前线程的node，设置lock status，将当前node指向前驱node(这样操作tail指向的就是前驱node等同于出队操作).至此CLH Lock的过程就结束了
CLH锁在 AQS 和 ObjectWaiter 实现的区别 AQS 使用的 CLH 锁，需要一个虚拟 head 节点，这个节点的作用是防止重复释放锁。当第一个进入队列的节点没有前置节点的时候，就会创建一个虚拟的。在前置节点释放锁的时候，肯定会唤醒这个节点。ObjectWaiter 对象里存放thread(线程对象) , 每一个等待锁的线程都会有一个ObjectWaiter对象，而objectwaiter是个双向链表结构的对象。当在某个线程A中调用wait()方法时，线程A会从RUNNABLE状态转变为WAIT状态，对应的ObjectWaiter会被移动到_WaitSet中等待被唤醒，并退出对象监视器，也就是释放锁，然后线程A被挂起。 小结CLH Lock是一种比较简单的自旋锁算法之一，因为锁的CAS操作涉及到了硬件的锁定(锁总线或者是锁内存)所以性能和CPU架构也密不可分，CLH Lock是独占式锁的一种，并且是不可重入的锁。