前言
ReentrantLock是基于AQS实现的可重入的独占锁，当然它可以实现公平锁和非公平锁，下面会一一进行讲解。这里一些AQS的知识就不过多的介绍，详细见我的AQS篇章https://www.jianshu.com/p/54d372425e54
类结构
public class ReentrantLock implements Lock, java.io.Serializable {
//内部类持有对象，是公平锁还是非公平锁，该对象继承了AbstractQueuedSynchronizer
private final Sync sync;
//默认初始化是非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
//传参true知道公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
//继承AQS框架
abstract static class Sync extends AbstractQueuedSynchronizer {
}
//非公平锁
static final class NonfairSync extends Sync {}
//公平锁
static final class FairSync extends Sync {}
}
源码分析
NonfairSync(非公平锁分析)
- lock加锁，如果获得锁将重入状态和数量改下，并设置独占线程为当前线程，否则继续获取资源
final void lock() {
//状态是0代表可以获取锁，如果内存中是0就获取锁,并cas改成1表示得到锁重入次数是1
if (compareAndSetState(0, 1))
//得到锁则将当前线程往爷爷类AbstractOwnableSynchronizer设置为拥有独占锁的线程
setExclusiveOwnerThread(Thread.currentThread());
//没获得锁
else
//请求获得资源
acquire(1);
}
- compareAndSetState(cas比较状态更新状态值，达到加锁的目的)
protected final boolean compareAndSetState(int expect, int update) {
// AbstractQueuedSynchronizer对象+状态偏移量找到内存的状态值
//如果内存的状态值和expect期望值相等，则用update更新内存的状态值
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
- acquire就是AQS框架讲到的了，这里不做太多的解释，详见AQS篇https://www.jianshu.com/p/54d372425e54
，这里只会对tryAcquire重写进行讲解
//获取资源，如果tryAcquire没获取到资源，则acquireQueued从等待队列自旋去获取资源
//如果依然没获取到则进入阻塞状态，当然如果acquireQueued在判断取到的线程已经被中断
//则调用selfInterrupt去打断线程
//参数arg,该值会传送到{@link #tryAcquire}，但否则不会被解释，可以代表任何内容,如reentrantLock传的是1。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
- tryAcquire（NonfairSync非公平锁对其进行重写）,尝试获取资源
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
- nonfairTryAcquire非公平锁获取，如果失败就返回false，如果锁还未被获取则设置独占线程，改重入次数，返回获锁成功，若果锁已经被获取，则累计重入次数设置为新的重入次数，返回获锁成功
//在sync内部的方法
//非公平锁获取资源
final boolean nonfairTryAcquire(int acquires) {
//当前线程
final Thread current = Thread.currentThread();
//获取父类AbstractQueuedSynchronizer的计数值
int c = getState();
//锁还未被获取
if (c == 0) {
//acquires=1传进来的，cas设置state的状态，改为已经被当前线程获得锁，并标记重入次数
if (compareAndSetState(0, acquires)) {
//设置当前线程为当前锁的独占线程
setExclusiveOwnerThread(current);
//获得锁成功
return true;
}
}
//状态！=0s说明已经被获得锁
//如果获得锁的独占线程是当前线程则可以继续获得锁
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;
}
FairSync(公平锁分析)
- lock加锁，如果获得锁将重入状态和数量改下，并设置独占线程为当前线程，否则继续获取资源。公平锁的lock少了设置重入次数和独占线程设置，而是自己调acquire直接获取资源
final void lock() {
acquire(1);
}
- acquire就是AQS框架讲到的了，这里不做太多的解释，详见AQS篇，这里只会对tryAcquire重新进行讲解
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
- tryAcquire(尝试获取公平锁)
//尝试获取公平锁
protected final boolean tryAcquire(int acquires) {
//当前线程
final Thread current = Thread.currentThread();
//锁的重入次数
int c = getState();
//锁还未被获取
if (c == 0) {
//hasQueuedPredecessors判断队列是否还有等待时间长的线程，也就是排在队列前的
//如果没有则比较设置重入值，获锁成功设置当前线程为锁的独占线程返回true
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//锁已经被获取，当前独占线程就是当前线程
else if (current == getExclusiveOwnerThread()) {
//累加重入次数
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
//设置新的重入次数
setState(nextc);
//获锁成功
return true;
}
//获锁失败
return false;
}
- hasQueuedPredecessors(查询是否有任何线程等待获取的时间比当前线程长)
判断等待队列里不止一个节点，队列里的下一个指针是空，则返回true，代表已经有等待节点
判断等待队列里不止一个节点，队列里的下一个指针不是空，则要判断头结点的下一个节点是不是当前线程，如果是则返回false,如果不是则返回true
//查询是否有任何线程等待获取的时间比当前线程长
//如果h==t成立，h和t均为null或是同一个具体的节点，无后继节点，返回false。
//如果h!=t成立，head.next是否为null，如果为null，返回true。什么情况下h!=t的同时h.next==null？？，
//有其他线程第一次正在入队时，可能会出现。见AQS的enq方法，compareAndSetHead(node)完成，还没执行tail=head语句时，
//此时tail=null,head=newNode,head.next=null。
//如果h!=t成立，head.next != null，则判断head.next是否是当前线程，如果是返回false，
//否则返回true（head节点是获取到锁的节点，但是任意时刻head节点可能占用着锁，也可能释放了锁（unlock()）,
//未被阻塞的head.next节点对应的线程在任意时刻都是有必要去尝试获取锁）
public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
tryLock(其实调用的就是Sync类的nonfairTryAcquire非公平获取资源方法)
没获取到锁就返回了不会跟lock一样还要一直阻塞
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
unlock(解锁)
调用的是AQS类的release方法
public void unlock() {
sync.release(1);
}
- AQS类的release方法，该方法的tryRelease是在ReentrantLock内部类Sync重新的
一般在老二获得资源后就会将自己设置为head，所以在释放资源的时候用head开始释放资源，并唤醒老二(后继节点)
//释放资源
public final boolean release(int arg) {
//将重入次数减到0后释放锁成功
if (tryRelease(arg)) {
//头结点
Node h = head;
//头结点不是空并且它的状态不是初始化阶段，如果是<0的状态会将当前节点置为0
//并且找到有效的后继节点进行释放
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
//释放成功
return true;
}
//释放失败
return false;
}
- tryRelease
试释放锁，releases释放次数，因为锁是可重入的，上了几次锁就要解锁几次
//尝试释放锁，releases释放次数，因为锁是可重入的，上了几次锁就要解锁几次
protected final boolean tryRelease(int releases) {
//减掉释放的锁就是还剩锁次数
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//已经完全解锁
if (c == 0) {
free = true;
//清空独占线程
setExclusiveOwnerThread(null);
}
//设置新的锁次数
setState(c);
//返回释放状态
return free;
}
有些方法没去讲，因为是调用AQS的方法，已经说过就不讲了
AQS详见我的AQS源码解析篇https://www.jianshu.com/p/54d372425e54
觉得还可以的话给我点点赞呀！！！！！