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