公平锁源码分析

公平锁是一种多线程同步机制，它可以保证多个线程按照请求锁的顺序依次获得锁。在Java中，公平锁的实现类是ReentrantLock，下面我们来分析一下它的源码。

ReentrantLock的构造函数如下：

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可以看到，ReentrantLock的构造函数接受一个boolean类型的参数fair，用来指定该锁是否为公平锁。如果fair为true，则创建一个FairSync对象，否则创建一个NonfairSync对象。这两个对象都是ReentrantLock的内部类，它们分别实现了公平锁和非公平锁的逻辑。

FairSync的实现如下：

static final class FairSync extends Sync {
    final void lock() {
        acquire(1);
    }

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

FairSync继承了Sync类，它实现了公平锁的逻辑。FairSync中的lock方法直接调用了acquire方法，acquire方法中会调用tryAcquire方法来尝试获取锁。tryAcquire方法首先判断当前锁的状态，如果状态为0，表示锁没有被占用，这时它会判断是否有等待队列中的线程，如果没有，则尝试获取锁。如果状态不为0，表示锁已经被占用，这时它会判断当前线程是否为锁的持有者，如果是，则直接增加锁的状态计数器，否则返回false表示获取锁失败。

NonfairSync的实现如下：

static final class NonfairSync extends Sync {
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

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

NonfairSync同样继承了Sync类，它实现了非公平锁的逻辑。NonfairSync中的lock方法首先尝试使用CAS操作来获取锁，如果成功则设置当前线程为锁的持有者，否则调用acquire方法。tryAcquire方法中调用了nonfairTryAcquire方法来尝试获取锁，这个方法与FairSync中的tryAcquire方法类似，只是它不会判断等待队列中的线程是否比当前线程更早请求锁。

总结一下，ReentrantLock实现了公平锁和非公平锁两种逻辑，它的内部类Sync、FairSync和NonfairSync分别实现了锁的基本逻辑，包括获取锁、释放锁等。在使用ReentrantLock时，我们可以选择使用公平锁或非公平锁，具体取决于我们的需求。