Java并发：重入锁 ReentrantLock

ReentrantLock 是一种可重入的互斥锁，它不像 synchronized关键字一样支持隐式的重进入，但能够使一个线程（不同的方法）重复对资源的重复加锁而不受阻塞。

ReentrantLock 的 Java类图：

其中抽象静态内部类 Sync 继承了 AQS，可见 ReentrantLock 是通过组合自定义同步器来实现锁的获取与释放。

ReentrantLock 的构造函数能控制锁的公平性表现：

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

公平锁的够减少“饥饿”发生概率，等待越久的请求越能够优先的到满足。

公平性与否是针对获取锁而言的，一个锁若是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序，先到先得。

公平性锁每次都是从同步队列中的第一个节点获取到锁，而非公平性锁会出现一个线程连续获取锁的情况，特别是刚释放锁的线程在次获取同步状态的几率会更大，使得其他线程在同步队列中等待。

在系统线程上下文切换方面上，非公平性锁的切换次数会明显少于公平性锁，因为公平性锁的切换开销相对更大，但是极少的线程切换能保证更大吞吐量。

ReentrantLock 类代码的基本结构：

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;

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

    //带参数的构造函数，决定是公平锁还是非公平锁
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    //抽象基类继承AQS，公平锁与非公平锁继承该类，并分别实现其lock()方法
    abstract static class Sync extends AbstractQueuedSynchronizer {
        abstract void lock();
        //省略..
    }
    
    //非公平锁实现
    static final class NonfairSync extends Sync {...}
    
    //公平锁实现
    static final class FairSync extends Sync {....}
   
    //锁实现，根据具体子类实现调用
    public void lock() {
        sync.lock();
    }

    //响应中断的获取锁
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    //尝试获取锁，默认采用非公平锁方法实现
    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);
    }

    //创建锁条件（从Condetion来理解，就是创建等待队列）
    public Condition newCondition() {
        return sync.newCondition();
    }

    //省略....
}

ReentrantLock 释放锁的方法，在抽象静态内部类 Sync 中，它会检查当前线程同步状态值（重复获取一次锁，状态值会增加），在释放同步状态时减少同步状态值，若该锁获取了 n 次，那么前（n-1）次返回的都是 false，只有同步状态完全释放了（c为0），才会把占有该资源的线程设置为空，并返回 true。

    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;
        }