public class MCSQueueLock {
    /**
     * CLH锁节点
     */
    private class MCSNode {
        /**
         * 持有后继者的引用
         */
        MCSNode next;
        /**
         * 默认未锁定
         */
        boolean locked = true;
    }

    /**
     * 当前节点
     * 每个线程拥有自己的副本用于记录自己线程中持有的CLH节点状态信息
     */
    private final ThreadLocal<MCSNode> curNode;
    /**
     * 最后一个队列种MCS节点的状态信息,指向最后一个申请锁的MCSNode
     * 【注意】这里用了java的原子系列之AtomicReference，能保证原子更新
     */
    private final AtomicReference<MCSNode> tailNode;


    MCSQueueLock() {
        // 初始化当前线程（即实例化锁的线程）的MCS节点，锁状态为false；next指针为null
        curNode = ThreadLocal.withInitial(MCSNode::new);
        // 初始化最后一个队列种CLH节点的状态信息
        tailNode = new AtomicReference<>();
    }

    void lock() {
        MCSNode myNode = curNode.get();
        MCSNode preNode = tailNode.getAndSet(myNode);
        int spinCount = 0;
        //类似的，preNode == null从tail中没获取到值标志没有线程占用锁
        if (preNode != null) {
            //获取前继节点的下个指针引用，也就是当前线程持有的锁的状态
            preNode.next = myNode;
            //在自己node的locked变量自旋
            while (myNode.locked) {
                spinCount++;
            }
        }
        System.out.println("线程" + Thread.currentThread().getName() + "自旋" + spinCount + "次后获取了锁");
    }

    void unlock() {
        MCSNode myNode = curNode.get();
        //获取下个指针的引用
        MCSNode next = myNode.next;
        int spinCount = 0;
        //如果有后继者，直接设置next.locked = false通知后继者结束自旋.
        //如果有执行下面操作
        if (next == null) {
            //设置成功表示设置期间也没有后继者加入，设置失败表示有后继者加入
            if (tailNode.compareAndSet(myNode, null)) {
                System.out.println("无后继节点直接释放锁");
                return;
            }
            //同样的需要等待lock()中step1完成
            while (next == null) {
                spinCount++;
            }
        }
        System.out.println("线程" + Thread.currentThread().getName() + "自旋" + spinCount + "次后释放锁");
        next.locked = false;
        //for CG
        next = null;
    }
}

public class MCSQueueLockTest extends Thread {
    private static int count = 0;

    private static MCSQueueLock lock = new MCSQueueLock();

    @Override
    public void run() {
        lock.lock();
        try {
            for (int i = 0; i < 1000; i++) {
                count++;
            }
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            MCSQueueLockTest clhQueueLockTest = new MCSQueueLockTest();
            threads[i] = clhQueueLockTest;
            threads[i].start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
        System.out.println("count=" + count);
    }
}