ReentranLock是我们常用的同步锁。它里面主要会用到的方法就是lock() unlock(),下面我们来看下它的源码实现。
首先它有两种锁的方式 公平锁 和 非公平锁。其中两者的区别在于非公平锁每个线程不管有没有比它先的，都直接去尝试获取锁，而公平锁会先判断存不存在有等待的线程，有等待的线程直接加入到队列。
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* 当我们调用这个方法的第一步就是CAS state值，这个方法保证在多个
线程的情况下只有一个线程会成功
如果设置成功 那就设置当前线程设置成aqs的owner
如果设置失败(表示当前已经有线程拿到了aqs的锁) 调用acquire(1)方法
这个方法在aqs里面
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 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;
}
我们走到acquire(1)，就能看到当没获取到锁的时候，首先还是会去尝试获取锁，因为可能最开始的线程已经执行完了，这个时候还是通过compareAndSetState去获取锁，并且此时是支持可重入的，也就是说如果当前aqs Owner的线程进来会把state的值+1。
下一步当第二次获取锁失败之后，会调用acquireQueued(addWaiter(Node.EXCLUSIVE), arg))方法，我们先看addWaiter(Node.EXCLUSIVE)的作用。
private Node addWaiter(Node mode) {
//初始化一个当前线程节点
Node node = new Node(Thread.currentThread(), mode);
// 找到队尾节点
Node pred = tail;
if (pred != null) {
//当队尾节点存在 把当前节点前置指针指向队尾节点
node.prev = pred;
//把当前节点设置成队尾节点 这个地方也用cas操作 因为可能同时存在很多线程在插入队尾 保证
只有一个线程插入成功
if (compareAndSetTail(pred, node)) {
//插入成功之后把之前的队尾的后置节点指向它 返回出去
pred.next = node;
return node;
}
}
//如果当前节点未成功放至队尾 进入该方法直到放至成功
enq(node);
return node;
}
private Node enq(final Node node) {
//自旋直至节点放置成功
for (;;) {
//获取队尾
Node t = tail;
if (t == null) { // 如果队尾为空 初始化空节点 并且头尾相连
if (compareAndSetHead(new Node()))
tail = head;
} else {
如果队尾存在，把当前节点放置进去
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
所以我们可以知道``addWaiter(Node.EXCLUSIVE)方法的作用就是把当前线程加入到aqs的队列里面。那么加入成功之后进行acquireQueued(Node, arg))```方法
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//自旋直到当前线程之前的线程全部释放锁 这边也是lock阻塞的原因
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
//如果它上一个节点是head并且获取到锁，把当前节点设置成head
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 清除被取消的线程 并且把前一个节点设置成single 在下一次自旋进行阻塞 等待唤醒
如果当前线程中断了 返回true 执行selfInterrupt()中断线程;
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
//出现异常
if (failed)
cancelAcquire(node);
}
}
以上就是非公平锁的加锁过程，下面介绍unlock()
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
//尝试释放锁
if (tryRelease(arg)) {
//获取当前的头结点
Node h = head;
if (h != null && h.waitStatus != 0)
//如果节点不为空 且状态不是0 说明这是个执行节点 下面释放下一个节点的阻塞状态
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
//获取当前的状态值减1
int c = getState() - releases;
//如果当前线程不是aqs拥有者 抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//如果减去1之后状态值为0 说明当前线程在aqs上的操作全部完成
//把状态值归0 返回true指向下一步 如果状态值不为0 释放失败
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
private void unparkSuccessor(Node node) {
/*
*把当前节点的状态归0
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
*获取头结点的下一个有效节点
* 如果节点存在 激活其中的线程 让它去获取锁
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
我们在unlock的代码中可以发现，它会激活处于等待中的下一个节点，让它去竞争锁。
