【JUC】1、Java AbstractQueuedSynchronizer - CLH部分（二）

本文是学习AQS期间记录的，一篇文章发太多内容，编辑的时候很卡，所以独立开一篇
AQS篇：https://blog.csdn.net/hhy107107/article/details/108041627

CLH介绍

CLH是一种基于单向链表的高性能、公平的自旋锁。
基于当前节点的前驱节点状态进行自旋(前驱节点如果处于加锁状态或等待状态，当前节点自旋；前驱节点未加锁状态，当前节点得到锁)
前驱节点解锁后，当前节点会结束自旋，并进行加锁。

要点：

1. 两个ThreadLocal变量，一个保存当前节点，一个保存前继节点
2. 队列是隐式存在的，多个线程安全的竞争tail（CAS方式实现）, 继而加入队列
3. 每个线程尝试用自己去替换tail节点，并把之前的tail节点记录为自己的prev节点。通过循环访问prev节点的lock标志位来等待获取锁。
4. 线程释放之后，将当前节点设置为前继节点，相当于队列的出队。

CLH Java实现

public class CLHLock implements Lock {
    private final ThreadLocal<Node> prev; //保存当前线程的前继节点
    private final ThreadLocal<Node> node; //保存当前线程的节点
    //类在初始化时会初始化tail节点，相当于head节点(注意对隐式队列的理解)
    private final AtomicReference<Node> tail = new AtomicReference<Node>(new Node());

    public CLHLock() {
        this.prev = new ThreadLocal<Node>() {
            @Override
            protected Node initialValue() {
                return null;
            }
        };
        this.node = new ThreadLocal<Node>() {
            @Override
            protected Node initialValue() {
                return new Node();
            }
        };
    }

    public void lock() {
        Node node = this.node.get(); //获取Threadlocal变量，每个线程私有
        node.lock = true;
        //CAS方式设置tail节点，设置成功，相当于加入队列
        Node prev = this.tail.getAndSet(node);
        //把之前的tail节点，存入自己的prev节点，并循环访问其lock标志位，等待释放
        this.prev.set(prev);
        while (prev.lock) ;
    }

    public void unLock() {
        Node node = this.node.get();
        node.lock = false;
        //线程释放锁之后，将当前节点设置为前继节点，相当于队列的出队（利于GC）
        this.node.set(this.prev.get());
    }

    private class Node {
        //默认初始化值为false
        private volatile boolean lock;
    }
}

public interface Lock {

    void lock();

    void unLock();
}

测试

public class Test {


    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(4, 4, 60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(20), new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build());
        Lock lock = new CLHLock();

        threadPoolExecutor.submit(() -> {
            lock.lock();
            System.out.println("hehe1");
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("释放锁");
            lock.unLock();
        });
        threadPoolExecutor.submit(() -> {
            lock.lock();
            System.out.println("hehe2");
        });
    }
}

---

参考
https://blog.csdn.net/claram/article/details/83828768