【JUC】1、Java AbstractQueuedSynchronizer - CLH部分（二）CLH介绍CLH Java实现

92 阅读 0 评论 61 点赞

我是靠谱客的博主会撒娇犀牛，这篇文章主要介绍【JUC】1、Java AbstractQueuedSynchronizer - CLH部分（二）CLH介绍CLH Java实现，现在分享给大家，希望可以做个参考。

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

CLH介绍

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

要点：

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

CLH Java实现

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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;
}
}

复制代码

1
2
3
4
5
public interface Lock {
void lock();
void unLock();
}

测试

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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");
});
}
}