高并发编程-ReentrantLock非公平锁深入解析

class X {
  private final ReentrantLock lock = new ReentrantLock();

  public void m() {
    lock.lock();
    try {
      // do some thing
    } finally {
      lock.unlock()
    }
  }
}

    //默认构造方法创建的是非公平锁
    public ReentrantLock() {
        //构造非公平锁
        sync = new NonfairSync();
    }

    public ReentrantLock(boolean fair) {
        //根据公平策略构造公平锁或非公平锁
        sync = fair ? new FairSync() : new NonfairSync();
    }

    abstract static class Sync extends AbstractQueuedSynchronizer {
        //此处省略内部代码，后面具体分析
    }

    static final class NonfairSync extends Sync{
        //此处省略内部代码，后面具体分析
    }

    //ReentrantLock类的lock方法
    public void lock() {
        //此时的sync是NonfairSync的实例对象，所以执行sync.lock()将执行NonfairSync类的lock()方法
        sync.lock();
    }
    
    //NonfairSync类的lock()方法
    final void lock() {
        //通过CAS设置AQS中state的值
        //如果此时state值等于0，也就是锁没有被其它线程持有，则返回true
        if (compareAndSetState(0, 1))
            //设置独占锁的当前所有者为当前线程
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //否则，尝试获取独占锁
            //acquire方法继承自AbstractQueuedSynchronizer
            acquire(1);
    }
    
    //AbstractQueuedSynchronizer类的acquire方法
    public final void acquire(int arg) {
        //调用tryAcquire方法尝试获取锁，如果成功则返回，否则先执行addWaiter方法，再执行acquireQueued方法
        //因为公平锁和非公平锁对锁持有的实现不同，所以这里的tryAcquire使用的是NonfairSync类中的实现
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            //中断当前线程
            selfInterrupt();
    }
    
    //NonfairSync类的tryAcquire方法
    protected final boolean tryAcquire(int acquires) {
        //nonfairTryAcquire方法继承自Sync类
        return nonfairTryAcquire(acquires);
    }
    
    //Sync类的nonfairTryAcquire方法
    final boolean nonfairTryAcquire(int acquires) {
        //获取当前线程
        final Thread current = Thread.currentThread();
        //获取AQS中state当前值
        int c = getState();
        //如果state当前值等于0
        if (c == 0) {
            //使用CAS修改state值
            //如果此时state值等于0，也就是锁没有被其它线程持有，则修改成功
            if (compareAndSetState(0, acquires)) {
                //设置独占锁的当前所有者为当前线程
                setExclusiveOwnerThread(current);
                //获取到锁
                return true;
            }
        }
        //如果独占锁的当前所有者是当前线程，锁重入的情况
        else if (current == getExclusiveOwnerThread()) {
            //将state值加一
            int nextc = c + acquires;
            //判断新值是否溢出
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            //更新state值
            setState(nextc);
            //获取到锁
            return true;
        }
        //获取不到锁
        return false;
    }
    
    //上面分析的代码可以清晰的看到，当锁没有被线程持有时的获取过程，
    //但是，如果锁此时被其它线程持有，即执行tryAcquire方法返回false，
    //此时将需要先执行addWaiter方法，将当前线程封装成Node节点，并将这个Node节点插入到同步等待队列的尾部，
    //然后执行acquireQueued方法，阻塞当前线程，具体实现代码分析如下:
    
    //addWaiter方法继承自AQS
    //将当前线程封装成Node节点，并将这个Node节点插入到同步等待队列的尾部
    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;
    }

    //acquireQueued方法继承自AQS
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //获取当前节点的前驱节点
                final Node p = node.predecessor();
                //如果当前节点的前驱节点是头结点，并且可以获取到锁，跳出循环并返回false
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //当前节点的前驱节点不是头结点，或不可以获取到锁
                //shouldParkAfterFailedAcquire方法检查当前节点在获取锁失败后是否要被阻塞
                //如果shouldParkAfterFailedAcquire方法执行结果是当前节点线程需要被阻塞，则执行parkAndCheckInterrupt方法阻塞当前线程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    //parkAndCheckInterrupt方法继承自AQS，用于阻塞当前线程
    private final boolean parkAndCheckInterrupt() {
        //阻塞当前线程，当前线程执行到这里即被挂起，等待被唤醒
        //当当前节点的线程被唤醒的时候，会继续尝试获取锁
        LockSupport.park(this);
        return Thread.interrupted();
    }

    //ReentrantLock类的unlock方法
    public void unlock() {
        //此时的sync是NonfairSync的实例对象
        //在NonfairSync中没有重写release方法，release方法继承自AQS，所以执行AQS的release方法
        sync.release(1);
    }
    
    //AQS的release方法
    public final boolean release(int arg) {
        //尝试释放持有的锁
        //如果释放成功，则从同步等待队列的头结点开始唤醒等待线程
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                //唤醒同步等待队列中的阻塞线程
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

    //尝试释放持有的锁
    protected final boolean tryRelease(int releases) {
        //将state值减去1
        int c = getState() - releases;
        //如果当前线程不是持有锁的线程，抛异常
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        //如果state的值等于零，则表明此锁已经完全被释放
        //如果state的值不等于零，则表明线程持有的锁(可重入锁)还没有完全被释放
        if (c == 0) {
            //free=true表示锁以被完全释放
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }

    //唤醒阻塞线程
    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        Node s = node.next;
        //如果后继节点为空或已被取消，则从尾部开始找到等待队列中第一个waitStatus<=0，即未被取消的节点
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            //唤醒等待队列节点中的线程
            //之前执行到parkAndCheckInterrupt方法的线程继续执行，再次尝试获取锁
            LockSupport.unpark(s.thread);
    }