#yyds干货盘点# JUC锁: ReentrantLock详解

缥帙各舒散，前后互相逾。这篇文章主要讲述#yyds干货盘点# JUC锁: ReentrantLock详解相关的知识，希望能为你提供帮助。
JUC锁: ReentrantLock详解
ReentrantLock源码分析
类的继承关系
ReentrantLock实现了Lock接口，Lock接口中定义了lock与unlock相关操作，并且还存在newCondition方法，表示生成一个条件。

public class ReentrantLock implements Lock, java.io.Serializable

ReentrantLock类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync与FairSync类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。下面逐个进行分析。
Sync类
Sync类的源码如下:

abstract static class Sync extends AbstractQueuedSynchronizer
// 序列号
private static final long serialVersionUID = -5179523762034025860L;

// 获取锁
abstract void lock();

// 非公平方式获取
final boolean nonfairTryAcquire(int acquires)
// 当前线程
final Thread current = Thread.currentThread();
// 获取状态
int c = getState();
if (c == 0)// 表示没有线程正在竞争该锁
if (compareAndSetState(0, acquires))// 比较并设置状态成功，状态0表示锁没有被占用
// 设置当前线程独占
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;

// 试图在共享模式下获取对象状态，此方法应该查询是否允许它在共享模式下获取对象状态，如果允许，则获取它
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;

// 判断资源是否被当前线程占有
protected final boolean isHeldExclusively()
// While we must in general read state before owner,
// we dont need to do so to check if current thread is owner
return getExclusiveOwnerThread() == Thread.currentThread();

// 新生一个条件
final ConditionObject newCondition()
return new ConditionObject();

// Methods relayed from outer class
// 返回资源的占用线程
final Thread getOwner()
return getState() == 0 ? null : getExclusiveOwnerThread();

// 返回状态
final int getHoldCount()
return isHeldExclusively() ? getState() : 0;

// 资源是否被占用
final boolean isLocked()
return getState() != 0;

/**
* Reconstitutes the instance from a stream (that is, deserializes it).
*/
// 自定义反序列化逻辑
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException
s.defaultReadObject();
setState(0); // reset to unlocked state

NonfairSync类
NonfairSync类继承了Sync类，表示采用非公平策略获取锁，其实现了Sync类中抽象的lock方法，源码如下:

// 非公平锁
static final class NonfairSync extends Sync
// 版本号
private static final long serialVersionUID = 7316153563782823691L;

// 获得锁
final void lock()
if (compareAndSetState(0, 1)) // 比较并设置状态成功，状态0表示锁没有被占用
// 把当前线程设置独占了锁
setExclusiveOwnerThread(Thread.currentThread());
else // 锁已经被占用，或者set失败
// 以独占模式获取对象，忽略中断
acquire(1);

protected final boolean tryAcquire(int acquires)
return nonfairTryAcquire(acquires);

FairSyn类
【#yyds干货盘点# JUC锁: ReentrantLock详解】FairSync类也继承了Sync类，表示采用公平策略获取锁，其实现了Sync类中的抽象lock方法，源码如下:

// 公平锁
static final class FairSync extends Sync
// 版本序列化
private static final long serialVersionUID = -3000897897090466540L;

final void lock()
// 以独占模式获取对象，忽略中断
acquire(1);

/**
* Fair version of tryAcquire.Dont grant access unless
* recursive call or no waiters or is first.
*/
// 尝试公平获取锁
protected final boolean tryAcquire(int acquires)
// 获取当前线程
final Thread current = Thread.currentThread();
// 获取状态
int c = getState();
if (c == 0)// 状态为0
if (!hasQueuedPredecessors() & &
compareAndSetState(0, acquires))// 不存在已经等待更久的线程并且比较并且设置状态成功
// 设置当前线程独占
setExclusiveOwnerThread(current);
return true;

else if (current == getExclusiveOwnerThread())// 状态不为0，即资源已经被线程占据
// 下一个状态
int nextc = c + acquires;
if (nextc < 0) // 超过了int的表示范围
throw new Error("Maximum lock count exceeded");
// 设置状态
setState(nextc);
return true;

return false;