ReentrantLock底层流程剖析---NonfairSync（）

ReentrantLock实现公平和非公平锁
是靠内部类sync实现的
而sync是继承于AQS（AbstractQueuedSynchronizer类）

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

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

当我们调用reentrantlock的lock方法时

//ReentrantLock默认调用的是内部类sync的lock方法  默认也就是NonfairSync的lock方法
 public void lock() {
        sync.lock();
    }

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

//AQS类
 protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

unsafe.compareAndSwapInt(this, stateOffset, expect, update);
//第一个参数是NonfairSync对象
//第二个参数是NonfairSync对象内存地址
//第三个参数是期望内存值
//第四个参数是修改值

看源码我们可以发现 NonfairSync重写了lock和tryAcquire方法
当我们调用reentrantlock的lock方法时 调用的是
NonfairSync的lock方法 此时先进行CAS(compareAndSetState)判断
调用父级AQS类的compareAndSetState 接着调用unsafe类的compareAndSwapInt方法

final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

修改成功的话就执行setExclusiveOwnerThread(Thread.currentThread());把当前线程设值到属性exclusiveOwnerThread（AQS的父级AOS类的属性 继承获得）
否则调用（AQS 的acquire方法）

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

因为NonfairSync重写了tryAcquire方法 所以调用NonfairSync的tryAcquire方法

protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }

调用sync内部类的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;
        }

因为第一次compareAndSetState 没有成功
进入到nonfairTryAcquire方法
先判断state==0 state是AQS的成员变量

    private volatile int state;

如果state为0 说明没有人得到锁（也就是修改compareAndSetState不成功）调用setExclusiveOwnerThread 设置线程为当前线程并返回
调用业务代码

否则有人得到锁 判断该线程是不是当前线程
如果是当前线程 state+=acquires 否则就返回false
继续调用acquireQueued（addWaiter(Node.EXCLUSIVE), arg）方法

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
//EXCLUSIVE默认值为null 

private Node addWaiter(Node mode) {
		//传入的mode参数为null 以当前线程构建node节点
        Node node = new Node(Thread.currentThread(), mode);
        
        Node pred = tail;
        //尾节点不为空 设置前置节点为尾节点
        if (pred != null) {
            node.prev = pred;
            //多线程同时抢尾节点 就通过compareAndSetTail调用
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

构造Node节点通过AQS里面的Node类

Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

尾节点为空 就设置当前节点为头结点
返回节点当前 Node

继续执行acquireQueued方法传入当前线程节点和参数

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            //注意，它是死循环
            for (;;) {
            	//p为前节点
                final Node p = node.predecessor();
                //如果前节点已经是haed节点了，此时可以尝试获取下锁，
            //如果获取锁成功了，就将自己设置为head节点并且回收原head节点。
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //设置前节点的状态为 SIGNAL，并且挂起当前线程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
        //如果某种情况下，跳出了死循环，并且failed值为true，则需要删除当前节点，取消等待涣
            if (failed)
                cancelAcquire(node);
        }
    }

    final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (RuntimeException ex) {
            cancelAcquire(node);
            throw ex;
        }
    }

仔细看看这个方法是个无限循环，感觉如果p == head && tryAcquire(arg)条件不满足循环将永远无法结束，当然不会出现死循环，奥秘在于第12行的parkAndCheckInterrupt会把当前线程挂起，从而阻塞住线程的调用栈。

shouldParkAfterFailedAcquire中：

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
	    do {
		node.prev = pred = pred.prev;
	    } while (pred.waitStatus > 0);
	    pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE. Indicate that we
             * need a signal, but don't park yet. Caller will need to
             * retry to make sure it cannot acquire before parking. 
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        } 
        return false;
    }

检查原则在于：

• 规则1：如果前继的节点状态为SIGNAL，表明当前节点需要unpark，则返回成功，此时acquireQueued方法的第12行（parkAndCheckInterrupt）将导致线程阻塞
• 规则2：如果前继节点状态为CANCELLED(ws>0)，说明前置节点已经被放弃，则回溯到一个非取消的前继节点，返回false，acquireQueued方法的无限循环将递归调用该方法，直至规则1返回true，导致线程阻塞
• 规则3：如果前继节点状态为非SIGNAL、非CANCELLED，则设置前继的状态为SIGNAL，返回false后进入acquireQueued的无限循环，与规则2同

    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

如前面所述，LockSupport.park最终把线程交给系统（Linux）内核进行阻塞。当然也不是马上把请求不到锁的线程进行阻塞，还要检查该线程的状态，比如如果该线程处于Cancel状态则没有必要

总体看来，shouldParkAfterFailedAcquire就是靠前继节点判断当前线程是否应该被阻塞，如果前继节点处于CANCELLED状态，则顺便删除这些节点重新构造队列。

至此，锁住线程的逻辑已经完成，下面讨论解锁的过程。

解锁

请求锁不成功的线程会被挂起在acquireQueued方法的for循环第二个if判断，以后的代码必须等线程被解锁锁才能执行，假如被阻塞的线程得到解锁，则执行interrupted = true;，即设置interrupted = true，之后又进入无限循环。不停tryAcquire直至成功

从无限循环的代码可以看出，并不是得到解锁的线程一定能获得锁，必须调用tryAccquire重新竞争，因为锁是非公平的，有可能被新加入的线程获得，从而导致刚被唤醒的线程再次被阻塞，这个细节充分体现了“非公平”的精髓。通过之后将要介绍的解锁机制会看到，第一个被解锁的线程就是Head，因此p == head的判断基本都会成功。