AQS源码探究---竞争锁资源
Sync 对AQS进行扩展公共方法并定义抽象方法的抽象类
FaireSync 实现公平锁的AQS的实现类
UnFairSync 实现非公平锁的ASQ的实现类
我使用例子进行的debug，然后一步一步看源码。例子在文章最后面
线程竞争锁资源
AQS的state解释：
0 表示锁没有被占用
1 表示锁被占用了
> 1 表示锁被重入了 PS： ReentrantLock是可重入锁
获得锁执行流程
创建ReentrantLock对象
// ReetrantLock 默认创建一个非公平锁的AQS
public ReentrantLock( {
sync = new NonfairSync(;
}然后我们调用lock方法请求锁
成功，即将锁的owner主人设置为当前线程，接下来就是回到线程中执行线程的任务。
失败，即进入acquire的流程。
static final class NonfairSync extends Sync {
final void lock( {
// 请求锁资源，如果将锁的state状态0改成1，即为成功获得锁资源
if (compareAndSetState(0, 1
// 将锁的拥有者设置为当前线程，里面就一句话没啥好看的
setExclusiveOwnerThread(Thread.currentThread(;
else
acquire(1;
}
}下面是AQS阻塞链表是由一个双向链表组成的。
CANCELLED = 1 表示线程已经被取消了
SIGNAL = -1 表示后继线程需要unpark解除阻塞，下图即表示。
锁竞争失败流程
- 进入acquire方法
public final void acquire(int arg {
// 首先再次请求锁
if (!tryAcquire(arg &&
acquireQueued(addWaiter(Node.EXCLUSIVE, arg
selfInterrupt(;
}首先会执行tryAcquire方法
protected final boolean tryAcquire(int acquires { // 注意：我们进入的是非公平锁的tryAcquire实现
return nonfairTryAcquire(acquires;
}再次进入nonfairTryAcquire(acquires方法
final boolean nonfairTryAcquire(int acquires {
final Thread current = Thread.currentThread(; // 获得当前线程
int c = getState(; // 获得当前线程的状态
if (c == 0 { // 如果状态为0即锁资源被释放现在处于空闲状态，会尝试获得锁
if (compareAndSetState(0, acquires {
setExclusiveOwnerThread(current;
return true;
}
}
else if (current == getExclusiveOwnerThread( { // 这里是可重入代码，后面解释
int nextc = c + acquires;
if (nextc < 0 // overflow
throw new Error("Maximum lock count exceeded";
setState(nextc;
return true;
}
return false; // 失败返回false。如果是成功获得锁或者是重入都会返回true。需要了解
}回到步骤1代码，如果是失败返回false取反true，就会继续执行if语句。成功取反后false就直接结束当前语句，就会直接回到线程执行线程代码了。
public final void acquire(int arg {
if (!tryAcquire(arg &&
acquireQueued(addWaiter(Node.EXCLUSIVE, arg // 这里是两个方法，需要一个一个来
selfInterrupt(;
}
// acquireQueued(addWaiter(Node.EXCLUSIVE, arg执行addWaiter方法，概括就是将没有获得锁的加入一个等待链表中。
private Node addWaiter(Node mode { // 刚创建的时候mode为null的
Node node = new Node(Thread.currentThread(, mode; // 首先创建一个node
// Try the fast path of enq; backup to full enq on failure
Node pred = tail; // 将尾部的引用给pred变量
if (pred != null { // 刚开始创建的时候pred是null的
node.prev = pred;
if (compareAndSetTail(pred, node { // 这个代码块就是cas尝试加入双向链表尾部
pred.next = node;
return node;
}
}
enq(node; // 这里是创建head和tail进的方法，和if (compareAndSetTail(pred, node失败进入
return node; // 方法返回由当前线程创建的node
}enq方法的进入条件
进行head和tail的初始化。
多线程下如果调用enq方法失败，就是当别的线程也进入了等待链表，此时tail就会改变，上面的cas就会false，没有返回，就会进行enq方法
private Node enq(final Node node {
for (;; {
Node t = tail; // 如果尾部为空就会进行初始化，没有的话不断进行cas尝试插入链表尾部。
if (t == null { // Must initialize 初始化链表
if (compareAndSetHead(new Node( // 我们可以看到head是指向一个没有参数的node对象的
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node {
t.next = node; // 注意t还是引用旧值，而tail已经更新引用为node了。
return t;
}
}
}
}疑问：
compareAndSetTail(t, node 方法在我初次遇见的时候很奇怪。为什么t还算指向了旧的node对象
这也是我基础不太扎实的原因吧。
执行acquireQueued方法，再次尝试获得锁，和进行阻塞
final boolean acquireQueued(final Node node, int arg {
boolean failed = true;
try {
boolean interrupted = false;
for (;; {
final Node p = node.predecessor(; // 获得node前驱
if (p == head && tryAcquire(arg { // 如果是第一个等待锁的线程，再次请求锁
setHead(node; // 请求成功就将该线程的node直接移出等待链表
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node && // 检查状态并更新前驱状态为-1，即表示有后继节点阻塞了。
parkAndCheckInterrupt( // 进入park，如果被中断返回true
interrupted = true;
}
} finally {
if (failed
cancelAcquire(node;
}
}在parkAndCheckInterrupt方法时进行park阻塞。
private final boolean parkAndCheckInterrupt( {
LockSupport.park(this;
return Thread.interrupted(;
}线程释放锁
- 调用unlock方法
public void unlock( {
sync.release(1;
}调用release方法
public final boolean release(int arg {
if (tryRelease(arg { // 进入tryRelease即尝试释放
Node h = head;
if (h != null && h.waitStatus != 0
unparkSuccessor(h;
return true;
}
return false;
}进入tryRelease的ReentrantLock实现
protected final boolean tryRelease(int releases {
int c = getState( - releases; // 获得当前的状态
if (Thread.currentThread( != getExclusiveOwnerThread( // 非获得锁线程抛异常
throw new IllegalMonitorStateException(;
boolean free = false;
if (c == 0 { // 如果没有重入直接释放锁将owner置为null
free = true;
setExclusiveOwnerThread(null;
}
setState(c; // 由于锁资源只有一个只有一个线程能更新状态，所以更新AQS状态不需要cas
return free;
}继续回到release方法，释放锁成功返回true，进入条件语句
public final boolean release(int arg {
if (tryRelease(arg { // 进入tryRelease即尝试释放
Node h = head;
if (h != null && h.waitStatus != 0 // 阻塞队列存在即头节点不为空且头节点的状态不为0，为0表示后面没节点阻塞了
unparkSuccessor(h;
return true;
}
return false;
}进入unparkSuccessor方法，就不贴源码了，简单介绍一下就是将头节点置空，将阻塞队列中第一个等待的node解除阻塞，将他放出来去抢锁资源。
非公平锁和公平锁的区别
看完源码，整明白了就是锁资源释放后会放第一个等待线程去抢锁。
其实只是释放了线程，但是同时有其他的线程进行争抢，就又会变成争抢的情况，还是可能被其他线程抢走锁资源。
公平锁
不然就是直接加入阻塞链表，从而实现了公平。
public final void acquire(int arg {
if (!tryAcquire(arg &&
acquireQueued(addWaiter(Node.EXCLUSIVE, arg
selfInterrupt(;
}DEBUG例子
@Slf4j
public class Test1 {
public static void main(String[] args {
ReentrantLock lock = new ReentrantLock(;
// Reentrantlock锁资源被拥有
new Thread((->{
lock.lock(;
try{
log.debug("运行中";
try {
Thread.sleep(2000000000;
} catch (InterruptedException e {
e.printStackTrace(;
}
}finally {
lock.unlock(;
}
}.start(;
// ReentrantLock阻塞链表初始化
new Thread((->{
lock.lock(;
try{
log.debug("运行中";
try {
Thread.sleep(2000000000;
} catch (InterruptedException e {
e.printStackTrace(;
}
}finally {
lock.unlock(;
}
}.start(;
// ReentrantLock 再次向阻塞链表添加线程
new Thread((->{
lock.lock(;
try{
log.debug("运行中";
try {
Thread.sleep(2000000000;
} catch (InterruptedException e {
e.printStackTrace(;
}
}finally {
lock.unlock(;
}
}.start(;
}
}