多线程之重入锁

重入锁ReentrantLock，表示该锁能够支持一个线程多资源的重复加锁。

它还支持获取锁时的公平和非公平性选择。

Mutex

Mutex是一个不支持重入的锁

• 当一个线程调用Mutex的lock()获取锁之后，如果再次调用lock()，则该线程会被自己阻塞
  • 原因是Mutex在实现tryAcquire(int acquires)时没有考虑占有锁的线程再次获取锁的场景，在调用tryAcquire(int acquires)时返回了false

synchonized

• synchonized关键字隐式地支持重入
  • 比如一个synchronized修饰的递归方法在执行时，执行线程在获取了锁之后仍能连续多次地获取该锁

ReentrantLock

在调用lock()时，已经获取到锁的线程能够再次调用lock()获取锁

公平性问题

• 如果在绝对时间上，先对锁进行获取的请求一定先被满足，那么这个锁是公平的；反之，是不公平的。
• ReentrantLock提供了一个构造函数，能够控制锁是否是公平的。
• 公平的锁机制往往没有非公平的效率高
  • 但是，并不是所有的场景都是以TPS作为唯一的指标，公平锁能够减少“饥饿”发生的几率

ReentrantLock如何实现重入和公平性

实现重入

1. 线程获取锁时，锁需要识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
2. 锁获取时计数自增，被释放时计数自减；当计数等于0时表示锁成功释放。

java.util.concurrent.locks.ReentrantLock.Sync#nonfairTryAcquire

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    /*判断当前线程是否为获取锁的线程
    * 如果是，则获取成功
    * 增加同步状态值并返回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;
}

java.util.concurrent.locks.ReentrantLock.Sync#tryRelease

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            /*判断当前线程是否为获取锁的线程
            * 如果是，则获取成功
            * 将状态值增加并返回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;
        }

公平性

在java.util.concurrent.locks.ReentrantLock.Sync#nonfairTryAcquire中，对于非公平锁，只需要CAS设置同步状态成功，就表示当前线程获取了锁，而公平锁则不同

java.util.concurrent.locks.ReentrantLock.FairSync#tryAcquire

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        /*相比非公平锁，增加了hasQueuedPredecessors()判断同步队列中当前节点是否有前驱结点
        * 如果其为true，则表示有线程比当前线程更早地请求锁，当前线程必须等待*/
        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;
}

参考资料：《Java并发编程的艺术》