ReentrantLock源码分析-CSDN博客

本文链接：https://blog.csdn.net/lf19960114/article/details/117676729

ReentrantLock源码实现分析整理

重入锁ReentrantLock实现了Lock接口，即实现了加解锁操作的基本API，在此基础上，ReentrantLock提供以下特性：

1.支持同一线程对资源的重复加锁，即同一线程重复调用lock方法不会堵塞，但后续解锁次数需要和加锁次数同步，才能真正意义地释放锁。

2.支持获取锁时的公平和非公平性选择，

类的内部结构：

v2-530a19a746fac9801193a285900f766e_1440w

在ReentrantLock，有3个非常核心的内部类：Sync,FairSync,NonfairSync，其中Sync继承自AbstractQueuedSynchronizer，提供了队列同步器的各个公平/非公平加解锁操作的核心实现，而FairSync和NonfairSync继承自Sync，主要实现了lock和tryAcquire方法。

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

// 获取锁，抽象方法，供ReentrantLock实现了Lock
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;
}

// 如果当前线程非持同步状态线程，会抛已成，否则递减状态值，直到状态值为0才真正释放锁
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() {
    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;
}

/**
 * 反序列化时特别注意将状态值设为0
 */
// 自定义反序列化逻辑
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();
    setState(0); // reset to unlocked state
}
}

在Sync类的加解锁操作定义中，一个突出特点是根据state来判定重入次数，如果state=0，说明没有线程获取同步状态，当前线程获取后，设置当前线程为独占线程（在子类lock方法实现），后续当前线程可不断重入加解锁，通过修改state值实现；修改后state不为0，则其他线程不能获取锁。

NonfairSync 非公平锁实现

NonfairSync非公平锁的核心实现逻辑在lock方法，会用cas，尝试将state值从0改到1，如果成功，则设置当前线程为独占线程，否则说明锁被占用，调用同步器acquire方法堵塞直到拿到同步状态。代码实现如下：

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

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

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

非公平锁的非公平性主要体现在nonfairTryAcquire里当state=0时，直接尝试compareAndSetState(0, acquires)，即如果当前没有线程占有锁，当前线程直接通过cas指令占有锁，而不管当前线程在队列的哪个位置。

FairSync 公平锁实现

FairSync公平锁完整主要实现了tryAcquire方法，对于lock方法，只是简单调用acquire(1)函数，核心实现逻辑放在tryAcquire()中，通过同步器分析直到，在调用acquire方法里，会优先调用tryAcquire()方法。公平锁的实现逻辑在tryAcquire()中完成。

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

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

// 尝试公平获取锁
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;
}
}

整体实现类似非公平锁的nonfairTryAcquire实现，主要区别是当状态为0时，判断当前线程是否为等待时间最久的，如果是则更新为独占线程，并返回加锁成功，否则返回失败。

判定当前线程是否为等待时间最久的在函数hasQueuedPredecessors中实现，实现逻辑也较为简单，因为线程是按照先后顺序进入同步队列的，所以同步队列最前面的节点必定是等待最久的节点。

public final boolean hasQueuedPredecessors() {
// 本地缓存头尾节点
Node t = tail; 
Node h = head;
Node s;
// 判断头节点的下一个节点是否为当前节点
return h != t &&
    ((s = h.next) == null || s.thread != Thread.currentThread());
}

ReentrantLock锁API实现

ReentrantLock实现了Lock接口，所有加解锁的实现细节都在Sync、NonfairSync、FairSync等内部类中实现，主要提供了于用户友好交互的锁操作API，具体实现如下：

private final Sync sync;

/**
 * 默认创建一个非公平锁
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * 可以传入fair=true来创建一个公平锁
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

/**
 * 堵塞获取锁
 */
public void lock() {
    sync.lock();
}

/**
 * 堵塞获取锁，可被打断
 */
public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

/**
 * 尝试加锁，无论成功失败立即返回
 */
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

/**
 * 在超时时间内堵塞加锁，加锁成功返回true，超时返回false，被打断则抛异常
 */
public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

/**
 * 尝试解锁，注意如果非当前线程占有锁会抛IllegalMonitorStateException
 */
public void unlock() {
    sync.release(1);
}

/**
 * 初始化一个条件对象
 */
public Condition newCondition() {
    return sync.newCondition();
}

/**
 * 如果当前线程持有锁，返回state，表示重入数，否则返回0
 */
public int getHoldCount() {
    return sync.getHoldCount();
}

/**
 * 判断是否被当前线程持有锁
 */
public boolean isHeldByCurrentThread() {
    return sync.isHeldExclusively();
}

/**
 * 判断是否已加锁，不一定是当前线程
 */
public boolean isLocked() {
    return sync.isLocked();
}

/**
 * 判断当前是否为公平锁
 */
public final boolean isFair() {
    return sync instanceof FairSync;
}

/**
 * 获取锁所属线程，如果没有返回null
 */
protected Thread getOwner() {
    return sync.getOwner();
}

/**
 * 判断同步队列中是否有堵塞同步线程
 */
public final boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
}

/**
 * 判断指定线程是否在同步队列中
 */
public final boolean hasQueuedThread(Thread thread) {
    return sync.isQueued(thread);
}

/**
 * 获取同步队列中的等待节点数
 */
public final int getQueueLength() {
    return sync.getQueueLength();
}

/**
 * 获取同步队列中的所有等待线程
 */
protected Collection<Thread> getQueuedThreads() {
    return sync.getQueuedThreads();
}

/**
 * 判断是否有条件对象的等待者
 */
public boolean hasWaiters(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}

/**
 * 获取条件对象中等待队列长度
 */
public int getWaitQueueLength(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}

/**
 * 获取条件对象的等待队列中的所有等待线程
 */
protected Collection<Thread> getWaitingThreads(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}

public String toString() {
    Thread o = sync.getOwner();
    return super.toString() + ((o == null) ?
                               "[Unlocked]" :
                               "[Locked by thread " + o.getName() + "]");
}