ReentrantLock源码阅读

java面试题网站：www.javaoffers.com
ReentrantLock 是jdk提供的一种锁机制，该锁支持公平锁和非公平锁这两种。这两种锁的实现原理是 通过一 锁队列，公平锁是按照锁队列顺序执行，而非公平锁则不是按照锁队列顺序执行，会存在锁竞争，因为新线程会和队列中等待的线程进行竞争，所以有可能新线程会竞争到锁（如果竞争不到则加入队列进行等待）。下图为类依赖关系。
NofairSync , FairSync 是 ReentrantLock 中的内部类。分别是非公平和公平锁。
接下来从源码入手，先查看NofairSync：
new ReentrantLock().lock(); //加锁代码。会执行那些逻辑呢？下面将会一步一步的解剖。

源码：

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

final void lock() {　//非公平锁加锁机制
    if (compareAndSetState(0, 1))//初次尝试获取锁，和锁对列中元素（等待锁）开始竞争。
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1); //进入等待队列，等待获取锁。
}

//父类public abstract class AbstractQueuedSynchronizer 中的方法
 public final void acquire(int arg) {
        if (
              //尝试获取锁，如果尝试失败 则 acquireQueued
             !tryAcquire(arg) &&
             //加入等待队列，并等待获取锁。
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

//尝试获取
protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
  //非公平获取      
final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();  //获取锁状态，state 的作用是重入。1代表第一次获取锁，1+代表重入状态，0代表释放状态/未持有锁状态。其他线程可以竞争获取。
            if (c == 0) {//0 未持有锁状态
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current); //获取成功，将线程设置为当前锁持有者
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) { //如果当前线程为锁持有者，则进行重入。
                int nextc = c + acquires; //重入加1
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            //尝试获取失败
            return false;
        }

//封装为node 并加入到队列中
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);//将当前线程封装为node对象
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        //如果队列中存在元素Node
        if (pred != null) {
            node.prev = pred; 将node和队列中的最后一个tail（Node）关联起来，并将该node设置为队列的tail(最后一个)
            if (compareAndSetTail(pred, node)) {//
                pred.next = node;
                return node;
            }
        }
        //不存在则初始化队列并将当前node加入队列，
        enq(node);
        return node;
    }

    //初始化队列并将当前node加入队列
    private Node enq(final Node node) {
        for (;;) {//循环，直到设置tail成功
            Node t = tail;
            //如果队列为空，则出事化队列并new Node最为head（该node为空node,没有绑定线程）
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head; //初始化时头和尾是同一个 空node
            } else {
                node.prev = t;//将node放入队列的尾部，并且和head（注意：初始化时头和尾是同一个）相关联起来。
                //node加入到队列中并设置为tail 
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }
    
    //必须要获取锁
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) { //循环直到获取到锁
                final Node p = node.predecessor(); 获取当前node 前一个node 
                //当p为head时则该node才会进行尝试获取锁（保证了必须是head的下一个才能获取锁），这样保证了队列中的元素是顺序获取锁的。因为队列初始化时将head设置为一个空node(没有绑定任何线程)，然后将真正的node(含有线程对象)追加到空node后面，所以要head的下一个node（真正的node,含有线程对象）去尝试获取锁，并且获取锁后并将其设置为head。因此 head代表 ‘空node’  或  ‘已经获取过锁的node’。所以我们只需保证  是 head的下一个node（未获取过锁）才可以去进行尝试获取锁。这样就保证了队列中的元素是顺序获取锁的。
                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);
        }
    }

以上分析的是非公平锁原理，核心点：队列中的元素是有序的获取锁，新来的（还未加入队列中的）会和队列中的head下一个node元素产生锁竞争，因此就不能保证老的（队列中的元素）元素会一定获取锁，有可能新来的会提前获取锁，所以就产生了非公平锁。

公平锁原理：
公平锁和非公平锁的大体结构逻辑是一样的，但是只有一个地方是不同的：

  //公平锁源码
  static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            //获取锁
            acquire(1);
        }

        /**
         * 尝试获取锁
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (   !hasQueuedPredecessors() //注意这里的取反！符号， 取反后的意思为：如果当前的Thread.currentThread()线程是 head的下一个元素中绑定的线程，则为true
                       &&
                    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;
        }
    }
    //如果当前的Thread.currentThread()线程是 head的下一个元素中绑定的线程，则返回false,否则是true
    //笔者不知写ReetrantLock作者为什么要这样写，并且还要在上面的逻辑中使用取反符号 ！,本人猜测这位大神平常很喜欢反向思考逻辑。如果是我肯定就写成: 前的Thread.currentThread()线程是head的下一个node绑定的线程就返回true,否则为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;
        //这里需要反向逻辑思考： 如果头和尾不相同，并且head头的下一个元素 s 不等于null,并且头的下一个元素绑定的线程 就是 当前的Thread.currentThread()线程，则返回false. (注意这里是反向逻辑理解，因此是返回false) 
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

公平锁原理总结： 必须保证是队列中head的下一个node,才可以去进行获取锁，因此保证了公平性，新来的元素，必须去队列中排队等待获取。