Java 中怎么实现公平锁与非公平锁

# Java 中怎么实现公平锁与非公平锁

## 一、锁的公平性概述

在多线程编程中，锁的公平性（Fairness）是指线程获取锁的顺序是否严格按照请求顺序分配。Java中的`ReentrantLock`提供了公平锁与非公平锁两种实现方式：

- **公平锁（Fair Lock）**：按照线程请求锁的顺序分配，先到先得
- **非公平锁（Nonfair Lock）**：允许插队，后请求的线程可能先获取锁

```java
// 创建公平锁
ReentrantLock fairLock = new ReentrantLock(true); 

// 创建非公平锁（默认）
ReentrantLock nonfairLock = new ReentrantLock(); 

二、底层实现原理

1. AQS 核心结构

两种锁的实现都基于AbstractQueuedSynchronizer（AQS）框架：

public class ReentrantLock implements Lock {
    private final Sync sync;
    
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 实现锁的核心逻辑
    }
    
    // 非公平锁实现
    static final class NonfairSync extends Sync { /*...*/ }
    
    // 公平锁实现
    static final class FairSync extends Sync { /*...*/ }
}

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

2. 公平锁实现

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()) {
        // ...同非公平锁...
    }
    return false;
}

四、性能对比测试

1. 测试代码示例

public class LockBenchmark {
    private static final int THREADS = 10;
    private static final int CYCLES = 100000;
    
    public static void testLock(ReentrantLock lock) {
        long start = System.currentTimeMillis();
        ExecutorService exec = Executors.newFixedThreadPool(THREADS);
        
        IntStream.range(0, CYCLES).forEach(i -> {
            exec.submit(() -> {
                lock.lock();
                try {
                    Thread.sleep(1);
                } finally {
                    lock.unlock();
                }
            });
        });
        
        exec.shutdown();
        while(!exec.isTerminated());
        System.out.println("Cost: " + (System.currentTimeMillis()-start));
    }
}

2. 典型测试结果

五、应用场景建议

适合使用公平锁的场景

1. 需要保证线程执行顺序的业务逻辑
2. 临界区执行时间较长的操作
3. 对延迟敏感的系统

适合使用非公平锁的场景

1. 高并发、高性能要求的场景
2. 临界区执行时间极短（<100μs）
3. 能容忍短暂饥饿的情况

六、扩展知识

1. synchronized的公平性

内置锁synchronized本质上是非公平锁，没有提供公平策略选项

2. 其他公平性实现

// 公平的Semaphore实现
Semaphore fairSemaphore = new Semaphore(1, true);

// 公平的读写锁
ReentrantReadWriteLock fairRwLock = 
    new ReentrantReadWriteLock(true);

七、常见问题解答

Q1: 为什么默认使用非公平锁？

因为在大多数场景下，非公平锁的吞吐量比公平锁高40%-100%

Q2: 公平锁如何避免饥饿问题？

通过维护一个FIFO队列，严格按顺序唤醒等待线程

Q3: 如何选择锁类型？

1. 优先尝试非公平锁
2. 当出现明显饥饿问题时改用公平锁
3. 对顺序有严格要求时使用公平锁

总结

理解公平锁与非公平锁的关键在于： 1. 公平锁通过hasQueuedPredecessors()保证顺序 2. 非公平锁通过”插队”机制提高吞吐 3. 选择时需要权衡公平性和性能 “`