JUC之ReentrantLock解读

`ReentrantLock`简介

ReentrantLock是可重入锁的实现，可重入锁的含义是：如果已经拥有锁的线程再次获取锁时会立即响应成功，这点可以使用isHeldByCurrentThread和getHoldCount方法来检验。ReentrantLock可重入互斥锁具有同synchronized的隐式监视器锁相同的基本行为和语义，但是其更具有扩展能力。

ReentrantLock提供公平锁和非公平锁的特性，如果设置为公平锁，那么锁倾向于访问等待时间最长的线程；如果是非公平锁，那便不会保证任何特定的访问顺序。公平锁会导致整体的吞吐量降低，不过却可以在最少的时间差内获取到锁和保证锁饥饿。不过请注意，锁是公平并不能保证线程调度的公平性。

`ReentrantLock`使用

典型用法如下（这里以lock为例，当然也可以用tryLock方法来获取锁）：

class X {
  private final ReentrantLock lock = new ReentrantLock();
  // ...

  public void m() {
    lock.lock();  // block until condition holds
    try {
      // ... method body
    } finally {
      lock.unlock()
    }
  }
}

`ReentrantLock`源码剖析

源码中涉及AQS模板类的调用，可选择先查看《JUC之AQS解读》这篇文章的介绍。

同步器

对于同步状态，依然是继承与AQS来实现的，考虑到有公平锁和非公平锁的特性，其又做了一层抽象，提供一些共用方法，如：

对于lock的加锁过程则交予具体的锁类型同步器去实现

获取非公平锁： nonfairTryAcquire
释放锁：tryRelease
是否当前线程持有锁：isHeldExclusively
条件对象：newCondition
对象序列化：readObject
线程持锁状态：getOwner，getHoldCount，isLocked等

其中获取非公平锁方式放在这个抽象层的原因是为了ReentrantLock在默认非公平性下调用:

1
2
3

public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

抽象同步器的源码如下：

abstract static class Sync extends AbstractQueuedSynchronizer {

    abstract void lock();

    final boolean nonfairTryAcquire(int acquires) {
      // 省略
    }

    protected final boolean tryRelease(int releases) {
      // 省略
    }

    protected final boolean isHeldExclusively() {
        // While we must in general read state before owner,
        // we don't need to do so to check if current thread is owner
        return getExclusiveOwnerThread() == Thread.currentThread();
    }

    final ConditionObject newCondition() {
        return new ConditionObject();
    }

    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }

    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }

    final boolean isLocked() {
        return getState() != 0;
    }
    
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

公平锁与非公平锁

ReentrantLock公平锁和非公平锁的特性可以通过选择如下构造函数来设定：

1
2
3

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

如果直接使用默认的无参构造函数，那么是用的非公平锁：

1
2
3

public ReentrantLock() {
    sync = new NonfairSync();
}

公平锁和非公平锁的同步状态器源码如下：

static final class NonfairSync extends Sync {

    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThreadcurrentThread(Thread.());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}
static final class FairSync extends Sync {

    final void lock() {
        acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            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;
    }
}

同时结合前面的抽象同步器代码，可以总结出区别在于：

非公平的加锁在最开始阶段会进行一次资源竞争抢占compareAndSetState(0, 1)，如果抢占成功则直接加上锁。
公平性加锁在尝试获取锁的时候，如果state==0的条件下多了一层判断!hasQueuedPredecessors()来保证公平有序。

hasQueuedPredecessors的作用是判断是否有其他线程先于当前线程进行等待，避免非公平抢占。其源码如下，通过判断是否有等待节点来告知：

public final boolean hasQueuedPredecessors() {
    Node t = tail; 
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

可重入性

对于可重入性，就是在判断到当前线程持有锁的时候，再将状态值进行加法：

else if (current == getExclusiveOwnerThread()) {
    int nextc = c + acquires;
    if (nextc < 0)
        throw new Error("Maximum lock count exceeded");
    setState(nextc);
    return true;
}

对于可重入的次数而言，由于继承的是AQS并使用其state字段，所以最大值只能到Integer.MAX_VALUE，超出此限制会抛出Error。

/**
 * The synchronization state.
 */
private volatile int state;

锁释放

回到抽象同步器的tryRelease方法，这是对锁释放的一个操作，其完成的功能有如下3步：

判断是否是当前线程，不是则抛异常；
释放状态值：state - releases;
如果状态值为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;
}

根据AQS模板类的使用，会根据如下调用流程走完锁释放流程：

1	ReentrantLock.unlock -> aqs.release -> ReentrantLock.tryRelease

ReentrantLock简介

ReentrantLock使用

ReentrantLock源码剖析

同步器

公平锁与非公平锁

可重入性

锁释放

`ReentrantLock`简介

`ReentrantLock`使用

`ReentrantLock`源码剖析