ReentranLock重入锁源码分析

今天来分析一下重入锁的源码

ReentranLock定义

重入锁ReentranLock是一种支持重进入的锁，表示该锁可以支持一个线程对资源重复加锁，并且分为公平锁和非公平锁

synchronized

synchronized大家一定都很熟悉了，这也是一种隐式的重入锁，是一种非公平锁

重进入的实现

1. 当线程再次获取锁时，锁需要先判断该线程是否为当前占据锁的线程，如果是则再次成功获取
2. 当释放锁时，如果线程重复n次获取了锁，必须要在第n次释放该锁后，其他线程才能够获取到该锁

源码解析

非公平锁的获取

当再次获取同步状态时，通过判断当前线程是否为锁的持有者来决定获取操作是否成功，成功则将同步状态值增加并返回true

    final boolean nonfairTryAcquire(int acquires) {
        // 判断当前线程是不是锁的持有者
        final Thread current = Thread.currentThread();
        // 获取同步状态值
        int c = getState();
        // 当锁没有持有者时，进行CAS操作，成功时，即将锁的拥有者设置为当前线程
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return 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;
    }

公平锁的获取

与非公平锁的获取区别为，需要在CAS操作的同时判断是否还有前驱结点，当没有前驱结点时才为下一次需要执行的线程

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

锁的释放

如果该锁被获取了n次，那么前n-1次tryRelease方法一定返回false，只有同步状态完全释放了才返回true，并且将锁的占有者设为空。

protected final boolean tryRelease(int releases) {
        // 当前同步状态值为锁当前的被持有数减去释放数
        int c = getState() - releases;
        // 如果当前线程不是锁的持有者，则抛出异常
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 只有当锁的持有数为0时，才会将锁的持有者移除，实现锁的释放
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        // 数量不为0时，将数量写回同步状态值
        setState(c);
        return free;
 }

公平锁与非公平锁的区别

1. 公平锁比非公平锁的的效率低，因为需要切换更多次，吞吐量降低
2. 公平锁能够减少饥饿发生的概率，因为非公平锁会使刚释放锁的线程再次获取同步状态的几率非常大，使得其他线程只能在AQS(同步队列)中等待

也许我们很渺小，但我们都要仰望星空的权利