ReentrantLock 公平锁与非公平锁

实例化

在实例化 ReentrantLock 的时候可以加一个构造参数。

// 传true时为公平锁
ReentrantLock lock = new ReentrantLock(true);

// 非公平锁
ReentrantLock lock = new ReentrantLock();

当然他们的构造方法也是不一样的

构造方法

// fair为true时为公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

// 默认非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}

此事我们发现 ReentrantLock 为了应对公平锁与非公平锁实现了两个类： FairSync 和 NonfairSync 。他们都是继承于 Sync 类。

lock

我们找到 FairSync 和 NonfairSync 类的 lock 方法，发现区别还是很明显的。

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


static final class NonfairSync extends Sync {
     final void lock() {
         // 发现非公平锁比公平锁多了一步
         if (compareAndSetState(0, 1))
             setExclusiveOwnerThread(Thread.currentThread());
         else
             acquire(1);
     }
}

公平锁在执行 lock 方法时会直接执行 acquire 方法，而非公平锁会先尝试替换一下状态，如果成功则设置当前线程为所有者。

tryAcquire

// 公平锁
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;
}

// 非公平锁
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;
}

貌似很多，是否公平的关键只是一个方法。

// 非公平
if (c == 0) {
    if (compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(current);
        return true;
    }
}

// 公平
if (c == 0) {
    // 多了一个hasQueuedPredecessors
    if (!hasQueuedPredecessors() &&
        compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(current);
        return true;
    }
}

hasQueuedPredecessors

翻译过来就是队列是否有前节点。

public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

头节点不是尾节点 且 （ 头节点的下一个节点不为空 或者 头节点的下一个节点不是当前节点 ）