关于lock:ReentrantLock-的公平锁与非公平锁

偏心锁与非偏心锁是指，多个线程在获取同一把锁的策略，是依照先到先得还是间接竞争。先到先得的策略就是偏心锁，排队对所有的线程来说是偏心的，间接竞争的策略则是非偏心的。

在调用ReenterantLock的构造函数的时候决定是结构一个偏心锁还是非偏心锁。

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

来看获取锁的过程：

ReentrantLock lock = new ReentrantLock();
lock.lock();

点进去看，是调用了sync的lock办法

这里就是对应了咱们的偏心锁/非偏心锁的lock办法。

到这里没有什么大的差别，无非是非偏心锁多了一个步骤。cas操作去尝试获取锁，胜利了设置owner线程为以后线程。失败了再调用acquire办法获取锁。
那接下来持续看两种锁的acquire办法，两个办法都来到了aqs的acquire办法。

点进去那些办法，所有办法都进入了aqs实现的步骤，只有tryAcquire办法有不同的实现。

进去看，偏心锁只是多了 hasQueuedPredecessors这个办法。

偏心锁

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {    // 以后锁的状态是无所状态
        if (!hasQueuedPredecessors() &&    // 判断队列中是否有前驱节点，若果有前驱节点，就不会执行上面的代码，不会去获取锁
            compareAndSetState(0, acquires)) {    // 应用cas尝试获取锁
            setExclusiveOwnerThread(current);    // 设置owner线程为以后线程
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {    // 持有锁的线程为以后线程
        int nextc = c + acquires;    
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);    // 更新sate（重入锁的原理）
        return true;
    }
    return false;
}

以上剖析了偏心锁和非偏心锁的一个不同。
上面以非偏心锁剖析加锁的过程
获取锁的过程：

/**
 * Performs lock.  Try immediate barge, backing up to normal * acquire on failure. */final void lock() {
    if (compareAndSetState(0, 1))   // 尝试用cas来获取锁（扭转state的值）
        setExclusiveOwnerThread(Thread.currentThread());    // 设置owner线程为以后线程
    else
 acquire(1); // 如果锁的状态不为0，被其余线程持有，尝试获取锁
}

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}   

tryAcquire(arg)办法是尝试获取锁。

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

原理和下面偏心锁的tryAcquire办法统一。

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))办法：
addWaiter办法：

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
 Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

创立一个node，入队，并返回该Node
acquireQueued再尝试获取锁

非偏心锁解锁的过程：

public final boolean release(int arg) {
    if (tryRelease(arg)) {  // 尝试去开释锁
        Node h = head;
        if (h != null && h.waitStatus != 0) // h头结点为空，并且state不等于0
            unparkSuccessor(h); // 去唤醒后继节点
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {   
        free = true;
        setExclusiveOwnerThread(null);      // 设置owner线程为空
    }
    setState(c);            // 更新state
    return free;
}