看java重入锁的代码，遇到了CLH队列锁，发现实现很巧妙，学习一下。

什么是自旋锁？说的是锁等待的实现方式，可以改变线程的状态，让其进入等待或者睡眠（具体状态还没研究），这就是使用线程最原生的方式实现。也可以让线程进入一个while循环，这是一种轻量级实现，没有设计线程状态的转换，节省了转换的开销，但是cpu开销可能很大，进入循环的方式就是自旋锁。

下面是一段很常见的理解CLH的代码：

class ClhSpinLock {
    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;
            }
        };
    }

    public void lock() {
        final Node node = this.node.get();
        node.locked = true;
        // 一个CAS操作即可将当前线程对应的节点加入到队列中，
        // 并且同时获得了前继节点的引用，然后就是等待前继释放锁
        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());
    }

    private static class Node {
        private volatile boolean locked;
    }
}

摘自：
http://www.cnblogs.com/zhanjindong/p/java-concurrent-package-aqs-clh-and-spin-lock.html

一个锁类有两种共享变量，第一种是线程私有的，即ThreadLocal类型，线程之间不会影响。另一种就是共享的，线程之间可见。

共享的是一个tail指针，指向整个等待队列的最后一个元素。这个也必须是共享的，否则各个线程就没有关系了。通过这个共享变量，把整个队列联系起来。另外两个变量是线程私有的，每一个线程在内部都有副本。myNode指的是当前线程对应的node，pred指的是当前线程的前驱节点。

在lock方法内，首先得到当前线程的myNode节点，这个是通过ThreadLocal的intialize方法实现的，默认返回一个新的节点代表当前线程。设置node的属性locked为true表明在使用锁，其后继节点就会在这个变量上循环。这时当前线程还没有和整个队列建立关系，所以接下来要通过全局的tail变量把自己接入队列。调用tail的getAndSet，得到当前的tail命名为pred，然后把自己设置为tail，那么pred就是当前节点的前驱节点。这个过程是通过CAS控制并发的。这时当前线程已经得到了前驱，而且把自己设置为tail，那么就先用自己的prev变量缓存前驱，在前驱上while循环。只有前驱把自己的locked设置为false，才会停止while。

这样每一个线程都通过这样的方法，用tail形成一个队列，然后在前驱自旋。整个构成是通过ThreadLocal来创建新的节点。