首页  流程图  详情

juc_AQS|LockSupport

2021-07-06 16:36:58   0  举报





AQS与LockSupport的源码解析

java

AQS

作者其他创作

大纲/内容

false

true

pred.next = node;将当前节点设置为原尾节点的下一个节点

addWaiter(Node mode)

state = 1

node.prev = pred; 将当前节点的上一个节点设置为尾节点

线程A

Lock lock = new ReentrantLock();Condition condition = lock.newCondition();

线程3

unlock

head(头节点) != null&&头节点的 waitStatus != 0

可以理解为：发放通行证

signal

//模板模式 protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); }

boolean

boolean failed = true;

开始

双向队列

Node p = node.pred;当前节点的上一个节点赋值给 p

线程2

可重入锁，就是获取到锁的线程，可以再次调用相同的锁，而其他线程无法获取已经有锁的状态

Node s = tail

ReentrantLock

Node

nextc < 0

没有获取到锁的线程，进入等待队列，通过自旋判断锁是否被释放，如果释放，则自己获取锁，如果不没有释放，则继续自旋。

font color=\"#4d9900\

ReentrantLock lock = new ReentrantLock();

源码解析

LockSupport.unpark(s.thread);解锁 s 线程

Node t = tail;

protected final boolean tryRelease(int releases) { //releases = arg = 1; int c = getState() - releases; //c = 锁状态值 - arg if (Thread.currentThread() != getExclusiveOwnerThread()) //如果当前线程 != 获取锁的线程 throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { //如果 c == 0；表明锁状态值为 0，无人持有锁 free = true; setExclusiveOwnerThread(null); //设置锁持有者为 null } setState(c); //设置状态值 return free; }

tryRelease(arg)尝试释放锁

AQS：抽象队列同步器，除了java自带的synchronized关键字之外的一种锁机制

Node head头

取反

Sync

c == 0

抽象方法有具体的实现：公平锁与非公平锁

unparkSuccessor(head);解阻塞 h节点

FairSync公平锁

addWaiter(Node mode) 逻辑

return false

return unsafe.font color=\"#990000\

NonfairSync非公平锁

这个方法 compareAndSwapInt 的意思是：比较并交换。其中 stateOffset 为实际值，expect 为期望值，update 为更新值。就是比较实际值与期望值是否相同，如果相同则将更新值赋值给实际值，返回 true。如果不等，取消赋值，返回 false。

tail != null &&tail != head

Lock方法的具体实现

方法

private Node enq(final Node node) { //node 当前线程节点 for (;;) { // for (;;) {} 相当于 while 循环 Node t = tail; //将尾节点赋值给 t if (t == null) { // Must initialize //初始化节点；如果尾节点是 null 的 if (compareAndSetHead(new Node())) //比较并 new Node() 设置为 head 头节点。compareAndSetHead 底层传值：实际值：头节点期望值：null 更新值：new Node() tail = head; //将头节点赋值给尾节点；即头指向尾 } else { //如果尾节点不是 null node.prev = t; font color=\"#000099\

true && true

return node;返回当前节点

sync.release(arg 1);

获取锁的线程修改锁的状态，state 由 0 => 1，当相同的线程再获取锁时，可以继续获取到，只是将 state 的值再加 1，这就是可重入。注意一点，获取多少次锁，则释放多少次锁，否则其他线程在获取锁时，查询锁状态 state 值不为 0，则其他线程获取不到锁。

pred != null

默认

tail.waitStatus <= 0

从等待队列中删除获得锁的线程

ReentrantLock 中的方法

设置当前线程持有锁

将当前线程设置为独占节点Node pred = tail;

boolean interrupted= false;

lock.unlock();

持有锁的线程

Lock

AQS = state + CLH变种的队列

AQS 中的方法

return true

//真实的逻辑 protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); }

next后

等待队列

falsearg = 1

private final boolean parkAndCheckInterrupt() { //阻塞当前线程进入排队等候队列 LockSupport.park(this); //当前线程阻塞，使用的是LockSupport.park() 方法 return Thread.interrupted(); //当当前线程解阻塞之后，检查线程是否中断，是返回 true 否返回 false }

sync.lock();

state = nextc

① free = true;② 设置当前没有线程持有锁

即将获取锁的线程

Thread

锁状态

addWaiter(Node.EXCLUSIVE)

继承

head.waitStatus < 0

prev前

end

加入等待队列末尾

parkAndCheckInterrupt()

线程C

c = state - arg

当前线程 != 获取锁的线程

acquireQueued(font color=\"#0000ff\

compareAndSetState 的具体实现

LockSuppor：等待唤醒机制（wait | notify）

1.不需要锁块就可以阻塞线程和唤醒线程2.不区分是先阻塞还是先解阻塞

return interrupted;

尝试释放锁

设置头节点为new Node();

设置当前线程节点为头节点

final boolean nonfairTryAcquire(int acquires) { //非公平锁尝试获取锁 final Thread current = Thread.currentThread(); //将当前线程赋值给 current int c = getState(); //将 AQS 的 state 值（状态值）赋值给 c if (c == 0) { font color=\"#000099\

设置当前线程持有锁；此时 state = 1；

nextc = c + 1

return

① !tryAcquire(arg)span style=\"font-size: inherit;\

s != null

Node tail尾

tryAcquire(arg)尝试获取锁1.获取当前线程 current2.获取 state 状态值 c

异常

wait

tail = head;尾节点也是空节点

lock.lock();

内部类