ReentrantLock

ReentrantLock

上一节分析了AbstractQueuedSynchronizer同步器的相关实现，现在在具体看下同步器的具体实现，也是大家常用的锁ReentrantLock，ReentrantLock重入锁，是指一个线程能够重复加锁。首先查看获取锁的lock()方法

Sync

ReentrantLock内部真正实现加锁的类是非公平锁NonfairSync和公平锁FairSync，都继承于Sync

继承关系类图

下面看下Sync类，Sync类里面含有抽象方法lock()，lock方法被子类实现来实现加锁的逻辑，因为Sync继承于AbstractQueuedSynchronizer，所以必须要实现tryAcquire()方法，Sync没有实现，需要子类去实现，Sync实现了nonfairTryAcquire()非公平加锁的方法

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();

    //如果同步状态为0 ，表示当前没有线程获取到锁
    if (c == 0) {
    //通过CAS方式，尝试获取同步状态
        if (compareAndSetState(0, acquires)) {
        //获取成功，则设置当前线程占有锁
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //需要考虑重入特性，如果当前线程已经获取了同步状态
    else if (current == getExclusiveOwnerThread()) {
    // 更新当前同步状态，
        int nextc = c + acquires;
       // 如果同步状态的值大于Integer.MAX_VALUE时，抛出异常
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 获取成功
        setState(nextc);
        return true;
    }
    // 获取失败
    return false;
}

1. 如果当前同步状态值为0，表示当前没有线程获取锁，那么通过CAS方式尝试获取同步状态，成功也加锁成功
2. 如果已经获取同步状态的线程就是当前线程，考虑到重入性，那么会更新同步状态，获取同步状态成功
3. 如果不满足上面两种情况，那么获取锁失败，返回false

下面再看下tryRelease()释放同步状态的方法

protected final boolean tryRelease(int releases) {
// 减去获取锁时加到同步状态上的值
    int c = getState() - releases;
    // 如果当前获取到同步状态线程的不是当前线程，则抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 是否释放了同步状态，因为重入的特性，只有当state == 0 时，才表明释放当前状态
    boolean free = false;
    if (c == 0) {
        free = true;
        // 设置当前获取同步状态的线程为null
        setExclusiveOwnerThread(null);
    }
    // 更新同步状态
    setState(c);
    // 返回释放完全释放同步状态
    return free;
}

1. 得到释放当前锁后，同步状态的最新值
2. 如果当前获取到同步状态线程的不是当前线程，则抛出异常
3. 如果state更新为0 ，那么就表示已经没有线程持有同步状态，否则表示还有线程拥有同步状态

NonfairSync

NonfairSync非公平锁与FairSync公平锁，这里会涉及到锁的公平性问题如果在绝对时间上，先对锁进行获取的请求一定先被满足，那么这个锁是公平的，反之，是不公平的。公平的获取锁，也就是等待时间最长的线程最优先获取锁，也可以说锁获取是顺序的。ReentrantLock提供了一个构造函数，能够控制锁是否是公平的。

看下NonfairSync的lock()

final void lock() {
// 因为是非公平锁，设置直接尝试获取同步同步状态 成功则表示加锁成功
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    //  设置同步状态失败，则尝试acquire()方法
    else
        acquire(1);
}

// 实现了AbstractQueuedSynchronizer的tryAcquire()，直接调用Sync的nonfairTryAcquire()
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

FairSync

公平锁

final void lock() {
// 与NonfairSync不同，没有通过CAS方式获取锁，直接调用acquire()
    acquire(1);
}

// 实现同步器的方法，
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
    // 如果没有前驱节点，才会尝试通过CAS获取同步状态
        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;
}

1. tryAcquire()与nonfairTryAcquire() 唯一的不同之处就在与!hasQueuedPredecessors() 在尝试通过CAS获取同步状态时，会先判断当前节点是否有前驱节点，如果没有前驱节点，则表明当前节点时头节点后的第一个节点，所以此时可以尝试获取同步状态，否则表明当前节点不是头节点的后一个节点，则为了保证公平性，不回去尝试获取同步状态

ReentrantLock

下面再看下ReentrantLock类

private final Sync sync;// 同步器


// 默认构造函数，sync时非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}

// 也可以由用户选择sync是公平锁还是非公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

public void lock() {
// 调用sync的方法
    sync.lock();
}

public boolean tryLock() {
// 直接调用非公平性尝试加锁
    return sync.nonfairTryAcquire(1);
}

public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
   //调用同步器的尝试加锁及超时设置
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

//释放锁
public void unlock() {
    sync.release(1);
}

通过上面的分析，就会对ReentrantLock的加锁和释放锁的操作就会很清楚了