高薪程序员必修课-Java中 ReentrantLock的公平锁和非公平锁底层实现原理

public class FairLockExample {
    private final ReentrantLock fairLock = new ReentrantLock(true); // 公平锁

    public void lockMethod() {
        fairLock.lock();
        try {
            // 关键代码区域
        } finally {
            fairLock.unlock();
        }
    }
}

底层实现

公平锁的实现依赖于 AbstractQueuedSynchronizer（AQS）中的FIFO队列。以下是关键的实现细节：

队列管理：AQS 维护一个FIFO队列，用于存放等待获取锁的线程。
锁的获取：在尝试获取锁时，如果队列中有其他线程在等待，当前线程会被加入队列，并阻塞等待。
锁的释放：在释放锁时，会从队列中唤醒下一个等待的线程，确保锁的公平性。

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) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

非公平锁（Non-Fair Lock）

原理

非公平锁在设计上为了提高性能，并不保证线程获取锁的顺序。相较于公平锁，非公平锁可以减少上下文切换，提供更高的吞吐量。

实现

抢占机制：非公平锁允许线程在每次请求锁时直接尝试获取锁，而不考虑等待队列中的其他线程。这种机制使得锁的获取变得不公平，但减少了线程的等待时间，提高了性能。
锁的获取：如果锁是空闲的，任何请求锁的线程都可以立即获得锁；如果锁被占用，线程会被加入等待队列。

示例代码

以下是非公平锁的简化实现示例：

public class NonFairLockExample {
    private final ReentrantLock nonFairLock = new ReentrantLock(false); // 非公平锁

    public void lockMethod() {
        nonFairLock.lock();
        try {
            // 关键代码区域
        } finally {
            nonFairLock.unlock();
        }
    }
}

底层实现

非公平锁的实现也是依赖于 AbstractQueuedSynchronizer（AQS），但在尝试获取锁时，非公平锁直接通过CAS操作尝试获取锁，而不是检查等待队列。

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

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) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

比较与选择

公平锁：适用于需要严格控制线程获取锁顺序，避免线程饥饿的场景，但可能会带来较多的上下文切换，影响性能。
非公平锁：适用于需要高性能的场景，通过减少上下文切换来提高吞吐量，但可能会导致线程饥饿问题。

总结

公平锁：通过维护FIFO队列，确保线程按照请求顺序依次获取锁，避免线程饥饿。
非公平锁：通过抢占机制直接尝试获取锁，提高性能和吞吐量，但可能导致线程饥饿。

⭐️ 好书推荐

《Effective Java中文版》

【内容简介】

本书是Jolt获奖作品Effective Java的第3版，对上一版进行了全面更新，涵盖了从Java 5到Java 9的种种特性，是Java开发人员不可缺少的一本参考书。

本书分为12章，包含90个条目，形式简洁。每个条目中都讲述了对Java的独到见解，阐明了如何编写高效、优雅的程序，并且提供了清晰、易懂的示例代码。与上一版相比，本书增加了Lambda表达式、流、Optional类、接口默认方法、try-with-resources、@SafeVarargs注解、模块等Java 7及以后所引入的新特性。本书介绍了如何充分利用泛型、枚举、注解、自动装箱、for-each循环、可变参数、并发机制等各种特性，帮助读者更加有效地使用Java编程语言及其基本类库（java.lang、java.util和java.io，以及子包，如java.util.concurrent和java.util.function等）。

📚 京东购买链接：【2024年全新译本】Effective Java中文版