浅析公平锁和非公平锁加锁过程

前言

     jdk1.8中的AQS（AbstractQuenedSynchronizer基类）提供了封装了做线程同步需要的基本方法acquire（获取资源）和release（释放资源）方法，ReentrantLock的子类FairSync和NotfairSync通过实现AQS的抽象方法tryAcquire（试图获取资源）和tryRelease（试图释放资源）方法实现公平和非公平的逻辑，所有公平和非公平的核心逻辑在tryAcquire和tryRelease两个方法中，本文结合源码分析公平锁和非公平锁的优缺点，关联关系和应用场景。

ReenrtantLock非公平锁的继承结构

ReenrtantLock公平锁的继承结构

一步一步分析非公平锁的加锁过程

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

        /*非公平锁的上锁过程*/
        final void lock() {
            /*state为一个原子int类型，即它的修改对所有线程是同步的，
            对state做cas操作，多线程同时操作的时候只有一个线程能够成功
            ，成功的线程将会活动执行权限，否则调用AQS的acquire方法
            */
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

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

AQS的acquire方法

public final void acquire(int arg) {
        //尝试获取锁，tryAcquire由NotfairSync实现
        //如果tryAcquire失败，就将当前线程包装成一个排他锁模式的Node对象（具体可以看addWaiter方法）然后入队列acquireQueued。
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

NotfairSync的tryAcquire方法调用了Sync的nonfairTrySync，即非公平锁是如何tryAcquire的

Sync的nonfairTrySync，通过代码可以看出来在非公平锁的tryAcquire过程中不会阻塞当前线程，如果acquire成功则直接将当前线程设置为可执行的线程，且state+1，这样其它线程在tryAcquire的时候发现state>0就会失败返回false。

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //当前的state值，state是一个原子计数器，累计有多少个线程请求上锁，一个线程执行结束调用release方法让state值-1，所有当state值为0的时候说明没有线程占用，当前线程可以直接执行
            int c = getState();
            if (c == 0) {
                //state为0，没有其他线程占用，当前线程被被设置为可执行线程。
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //当前线程已经是可执行线程，再次tryAcquire（同一个线程获取了执行权限后可以再次tryAcquire，不影响这个线程的执行，需要修改state的值），
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                //state值不能为负数，对参数acquires没做负数限制，所以在给state设置值的时候做校验
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

NotfairSync如果tryAcquire失败了会怎么做？

如图tryAcquire失败触发acquireQueued

public final void acquire(int arg) {
        //尝试获取锁，tryAcquire由NotfairSync实现
        //如果tryAcquire失败，就将当前线程包装成一个排他锁模式的Node对象（具体可以看addWaiter方法）然后入队列acquireQueued。
        if (!tryAcquire(arg) &&
            //tryAcquire失败触发acquireQueued
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

继续跟踪acquireQueued，这个方法就比较复杂了

首先，我们知道tryAcquire失败的线程都会入队列，AQS维护了一个队列用来让多个线程tryAcquire失败的时候排队（原子性的），方法是addWaiter，上面可以看到，这个方法具体就不在这细节展开了，我们知道它可以原子性的让多个tryAcquire失败的线程进入一个等待队列就行了。

然后我们再看AQS的acquireQueued方法，

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                //如果当前节点已经是队列的第一个节点，自旋tryAcquire，直到成功，成功后退出本方法，让当前节点作为head节点（head节点只是一个标记用来判断双链表中的某个节点是否是队列第一个节点即即将获得执行权限的节点）
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
       
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
           //如果发生异常则将当前Node设置为CANCELLED
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

如果当前Node不是第一个节点，则调用shouldParkAfterAcquire，是否当前节点需要阻塞（挂起线程），源码如下

这个方法涉及到Node的waitStatus切换过程，当前排队的节点如果是SIGNAL状态，就返回true表示需要阻塞，等待可用资源，如果为CANCELLED，将当前节点前面的所有waitStatus为CANCELLED的节点都移除，当前CANCELLED节点保留，如果状态为NONE,PROPAGATE,CONDITION，直接覆盖为SIGNAL，return false，下次循环（方法的外层是死循环）到这个方法的时候就返回true。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
         //node的前驱节点的waitStatus
        int ws = pred.waitStatus;
         //前驱节点是就绪状态
        if (ws == Node.SIGNAL)
            return true;
        //waitStatus>0表示CANCELLED，所以直接从双链表中移除这些节点，将node前面的CANCELLED状态的节点全部移除
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            //其它的waitStatus如NONE,PROPAGATE,CONDITION直接覆盖为SIGNAL
            //处于SIGNAL状态的节点直接阻塞
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

如果shouldParkAfterFailedAcquire返回true，则阻塞当前线程，当前线程阻塞结束（调用LockSupport.unpark或者interrupt方法的时候）返回当前线程的打断状态（是否是因为调用了inturrupt方法退出），代码如下

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

继续跟踪acquireQueued中的cancelAcquire方法，在这里简单解释下cancalAcquire方法到底做了些什么事情。

cancalAcquire方法当tryAcquire方法抛出异常的时候触发，如果某个线程tryAcquire失败，则调用cancelAcquire，cancelAcquire方法实际上将无效的Node移除并更新队列，cancel当前节点，根据当前节点在队列中的位置有三种情况

1.node在队列尾部，直接将node的前一个节点设置为tail

2.node在队列中部，将移除node，判断node前驱节点的状态，如果状态不为SIGNAL则改为SIGNAL，进入SIGNAL状态的线程如果获取不到执行权限将被挂起

3.node在队列头部，unpark node后的第一个就绪的线程，即该node的waitStatus<=0

具体代码

private void cancelAcquire(Node node) {
        // Ignore if node doesn't exist
        if (node == null)
            return;

        node.thread = null;

        // Skip cancelled predecessors
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // predNext is the apparent node to unsplice. CASes below will
        // fail if not, in which case, we lost race vs another cancel
        // or signal, so no further action is necessary.
        Node predNext = pred.next;

        // Can use unconditional write instead of CAS here.
        // After this atomic step, other Nodes can skip past us.
        // Before, we are free of interference from other threads.
        node.waitStatus = Node.CANCELLED;

        // If we are the tail, remove ourselves.
        if (node == tail && compareAndSetTail(node, pred)) {
            compareAndSetNext(pred, predNext, null);
        } else {
            // If successor needs signal, try to set pred's next-link
            // so it will get one. Otherwise wake it up to propagate.
            int ws;
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                pred.thread != null) {
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
                unparkSuccessor(node);
            }

            node.next = node; // help GC
        }
    }

公平锁FairSync的tryAcquire方法

对比非公平锁NotfairSync的tryAcquire方法，公平锁需要判断队列中是否有排队的线程，如果有排队的线程，则tryAcquire失败，

但是NotfairSync即使在队列有排队线程的时候，只要state=0就会去获取锁，这就是公平锁和非公平锁的区别所在。

protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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;
        }