移步java多线程系列文章

• 重入锁ReentrantLock，支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。
• synchronized关键字隐式的支持重进入**，比如一个synchronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获得该锁
• ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。
• 锁（如Mutex和ReentrantLock）基本都是排他锁，这些锁在同一时刻只允许一个线程进行访问

1 公平和非公平

• 锁获取的公平性问题，如果在绝对时间上，先对锁进行获取的请求一定先被满足，那么这个锁是公平的，反之，是不公平的。
• 公平的获取锁，也就是等待时间最长的线程最优先获取锁，也可以说锁获取是顺序的。
• ReentrantLock提供了一个构造函数，能够控制锁是否是公平的。
• 公平的锁机制往往没有非公平的效率高，但是，并不是任何场景都是以TPS作为唯一的指标，公平锁能够减少“饥饿”发生的概率，等待越久的请求越是能够得到优先满足。
• 公平性与否是针对获取锁而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序，也就是FIFO。

2 实现重进入

• 重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞

• 该特性的实现需要解决以下两个问题

  • 1）线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
  • 2）锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。

• ReentrantLock是通过组合自定义同步器来实现锁的获取与释放

2.1 非公平性（默认的）获取锁

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

该方法增加了再次获取同步状态的处理逻辑：

• 通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程再次请求，则将同步状态值进行增加并返回true，表示获取同步状态成功。
• 成功获取锁的线程再次获取锁，只是增加了同步状态值，这也就要求ReentrantLock在释放同步状态时减少同步状态值

2.2 非公平性（默认的）释放锁

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

• 如果该锁被获取了n次，那么前(n-1)次tryRelease(int releases)方法必须返回false，而只有同步状态完全释放了，才能返回true。
• 可以看到，该方法将同步状态是否为0作为最终释放的条件，当同步状态为0时，将占有线程设置为null，并返回true，表示释放成功。

2.3 公平锁

• 公平性与否是针对获取锁而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序，也就是FIFO。
• nonfairTryAcquire(int acquires)方法，对于非公平锁，只要CAS设置同步状态成功，则表示当前线程获取了锁，而公平锁则不同

　ReentrantLock的tryAcquire方法  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;
}

该方法与nonfairTryAcquire(int acquires)比较，唯一不同的位置为判断条件多了hasQueuedPredecessors()方法，即加入了同步队列中当前节点是否有前驱节点的判断，如果该方法返回true，则表示有线程比当前线程更早地请求获取锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

3公平与非公平对比

public class FairAndUnfairTest {
    private static Lock    fairLock        = new ReentrantLock2(true);
    private static Lock    unfairLock    = new ReentrantLock2(false);
    @Test
    public void fair() {
            testLock(fairLock);
    }
    @Test
    public void unfair() {
            testLock(unfairLock);
    }
    private void testLock(Lock lock) {
            // 启动5个Job（略）
    }
    private static class Job extends Thread {
            private Lock    lock;
            public Job(Lock lock) {
                    this.lock = lock;
            }
            public void run() {
                    // 连续2次打印当前的Thread和等待队列中的Thread（略）
            }
    }
    private static class ReentrantLock2 extends ReentrantLock {
            public ReentrantLock2(boolean fair) {
                    super(fair);
            }
            public Collection<Thread> getQueuedThreads() {
                    List<Thread> arrayList = new ArrayList<Thread>(super.
                    getQueuedThreads());
                    Collections.reverse(arrayList);
                    return arrayList;
            }
    }
}

分别运行fair()和unfair()两个测试方法

qq_pic_merged_1535261747080.jpg

• 结果（其中每个数字代表一个线程）
  • 公平性锁每次都是从同步队列中的第一个节点获取到锁
  • 非公平性锁出现了一个线程连续获取锁的情况。
• 而非公平性锁出现了一个线程连续获取锁的情况。 为什么会出现线程连续获取锁的情况呢？回顾nonfairTryAcquire(int acquires)方法，当一个线程请求锁时，只要获取了同步状态即成功获取锁。在这个前提下，刚释放锁的线程再次获取同步状态的几率会非常大，使得其他线程只能在同步队列中等待。
• 非公平性锁可能使线程“饥饿”，为什么它又被设定成默认的实现呢？再次观察上表的结果，如果把每次不同线程获取到锁定义为1次切换，公平性锁在测试中进行了10次切换，而非公平性锁只有5次切换，这说明非公平性锁的开销更小。

测试运行时系统线程上下文切换的次数
下面运行测试用例（测试环境：ubuntu server 14.04 i5-34708GB，测试场景：10个线程，每个线程获取100000次锁），通过vmstat统计测试运行时系统线程上下文切换的次数

qq_pic_merged_1535261885935.jpg
在测试中公平性锁与非公平性锁相比，总耗时是其94.3倍，总切换次数是其133倍。可以看出，公平性锁保证了锁的获取按照FIFO原则，而代价是进行大量的线程切换。非公平性锁虽然可能造成线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。

参考

《java并发编程的艺术》