ReentrantLock 公平锁和非公平锁源码分析

while(i<1000000) {
    lock();
    //dosomething();
    unlock();
}

public Lock lock = new ReentrantLock();
lock.lock();
//dosomeing()
lock.unlock();

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

public void lock() {
    sync.acquire(1);
}

//内部类 FairSync 方法
final void lock() {
    acquire(1);
}


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

//该代码位于FairSync中。主要逻辑当前线程获取尝试获取锁
//如果state=0说明当前没有线程获取锁，该线程可以获取，首先判断时候需要进队列hasQueuedPredecessors()
//如果不需要进队列则尝试设置state=1，设置成功以后当前线程获取锁成功，否则时报
//如果state=1说明该锁已经被线程占有，判断当前线程是不是自己，如果是再次获取锁，否则获取失败，返回false
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //判断时候需要进队列，需要进队列，则返回true整个方法结束，返回false；不需要则cas修改state的值
        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;
}

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;
    // h != t 如果为true说明队列里有其它线程，
    //判断头节点的下一个节点是否指向为空，或者指向自己，如果不是则返回true，说明当前线程需要排队
    //
    return h != t && ((s = h.next) == null || s.thread != Thread.currentThread());
}

//EXCLUSIVE意为独占锁
//下面的逻辑就是获取当前队列的最后一个节点，然后最后一个节点的next指向下一个节点，tail尾节点指向当前节点，这样当前节点就入队了。
//此时不得不感叹一下，大神写的几行代码，是真的厉害。
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;
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //获取当前线程节点的前继节点
            final Node p = node.predecessor();
            //如果当前线程的前继节点为头节点，那么说明当前线程很有可能获取锁，那么它再次尝试获取锁
            //再次进入tryAcquire(arg),再执行一边获取锁的逻辑。
            //return h != t && ((s = h.next) == null || s.thread != Thread.currentThread());
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

final void lock() {
    //不管队列里有没有线程等待，都直接尝试获取锁
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}