手把手带你剖析ReentrantLock的底层实现AQS

一.引言

在面试过程中发现很多人对synchronized关键字还能说出点东西,但是当问到ReentrantLock的时候，大部分的应试者的回答都是不知道。今天呢我们就手把手来剖析一下ReentrantLock的底层实现。下面让我们一起打开源码来看看吧。

二.ReentrantLock的使用

ReentrantLock的使用我们就不多说了。

        //默认非公平锁
        ReentrantLock lock  = new ReentrantLock();
        //实现公平锁
        ReentrantLock lock  = new ReentrantLock(true);

        try {
            lock.lock();
            //.....同步代码块逻辑
        }catch (Exception e){
           
        }finally {
            //必须finally语句块中解锁
            lock.unlock();
        }

三.ReentrantLock#lock()

1.ReentrantLock#lock()

我们直接来看ReentrantLock的lock方法的实现。

    //构造方法中决定成员变量sync的实现是FairSync还是NonfairSync
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
    //lock方法直接调用sync的lock方法
    public void lock() {
        sync.lock();
    }

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

        final void lock() {
            //这里直接调用的AbstractQueuedSynchronizer的实现
            //这里如果成功将AbstractQueuedSynchronizer的state值设置为1,代表没有出现多线程竞争的情况直接把当前线程设置为独占线程就好了，否则调用acquire方法。
            //如果当前STATE不为0,代表当前有线程占有了临界资源
            //compareAndSetState就会失败，直接调用acquire方法
            if (compareAndSetState(0, 1))
             //将当前线程设置为独占线程。
             setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
    }
    
    //Sync是ReentrantLock内部的一个继承自AbstractQueuedSynchronizer的静态抽象类
    //AbstractQueuedSynchronizer：抽象的队列同步器简称AQS
    //是ReentrantLock的核心，同时也是其他同步工具CountDownLatch,Semaphore等的核心，有兴趣的朋友在看完这篇文章后,可以自己手动去分析下CountDownLatch，Semaphore的实现
    abstract static class Sync extends AbstractQueuedSynchronizer {}

可以看到ReentrantLock的lock方法直接调用了内部成员变量sync的lock方法,这里我们直接分析非公平的实现NonfairSync的实现。

2.AbstractQueuedSynchronizer#compareAndSetState()

    //compareAndSetState方法直接调用Unsafe类compareAndSwapInt的方法,保证原子性的替换state的值
    protected final boolean compareAndSetState(int expect, int update) {
        return U.compareAndSwapInt(this, STATE, expect, update);
    }

3.AbstractQueuedSynchronizer#acquire()

    public final void acquire(int arg) {
        //直接调用tryAcquire去尝试获取锁
        //如果尝试获取锁不成功调用acquireQueued
        //selfInterrupt挂起当前线程
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

4.NonfairSync#tryAcquire()

       protected final boolean tryAcquire(int acquires) {
            //直接调用父类Sync的nonfairTryAcquire方法
            return nonfairTryAcquire(acquires);
        }

5.Sync#nonfairTryAcquire()

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //如果AbstractQueuedSynchronizer的stateE等于0
            //代表当前没有线程占有临界资源 
            //直接调用compareAndSetState，如果CAS成功就把当前线程设置为独占线程
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果state不为0,判断占有临界资源的线程是否和当前获取锁的线程是一个线程，如果是调用setState重置当前state的值，这里我们可以看出来，ReentrantLock它是可重入的锁和synchronized一样
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            //尝试获取锁还是失败的话
            //回到AbstractQueuedSynchronizer的addWaiter方法
            return false;
        }

6.AbstractQueuedSynchronizer#addWaiter()

    private Node addWaiter(Node mode) {
        //节点类型有两种 
        //SHARED共享模式  EXCLUSIVE独占模式
        //新建一个独占节点
        Node node = new Node(mode);
        //这里通过自旋和CAS的方法将当前节点添加的队列的尾部
        //AbstractQueuedSynchronizer内部有两个成员变量head和tail,这里其实就是双向链表实现的一个双端队列。head 和 tail 分别指向双端队列的头尾节点。
        for (;;) {
            Node oldTail = tail;
            //如果队列不为null将当前节点插入队列的尾部
            if (oldTail != null) {
                U.putObject(node, Node.PREV, oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return node;
                }
            } else {
                //否者初始化这个队列
                //队列头节点和尾节点都指向当前节点。
                initializeSyncQueue();
            }
        }
    }

7.AbstractQueuedSynchronizer#acquireQueued()

在调用addWaiter把当前节点放到双端队列的尾部后回到acquireQueued方法

    final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                //这里再次通过tryAcquire尝试去获取锁，如果获取锁成功 则不需要挂起当前线程
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                //如果上面尝试获取锁还是不成功，就根据前驱节点判断是否要阻塞 然后调用parkAndCheckInterrupt挂起当前线程。
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

8.AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire()

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        //获取前驱节点的状态
        int ws = pred.waitStatus;
        //如果前驱节点状态SIGNAL返回true表示当前线程要挂起
        if (ws == Node.SIGNAL)
            return true;
        if (ws > 0) {
            //如果前驱节点状态>0为CANCELLED状态，删除当前节点，并向前遍历找到一个CANCELLED状态的节点
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            //当前驱节点状态为0或者PROAGATE(-3)
            //设置前驱节点的等待状态为SINGAL
            //重新进入上面的死循环后 tryAcquire如果还是不成功 前驱节点的状态就是SIGNAL了 当前这个线程就会被挂起
            pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
        }
        return false;
    }

     补充:
     waitStatus取值一共有5中取值
     //当前线程因为超时或者中断被取消
     static final int CANCELLED =  1;
     //当前线程的后继线程被阻塞或者即将被阻塞
     //当前现场释放锁或者取消后需要唤醒后继线程
     static final int SIGNAL    = -1;
     //当前线程在condition队列中
     static final int CONDITION = -2;
     //将唤醒后线程传递下去，这个状态是为了完善
     //共享锁的唤醒机制
     static final int PROPAGATE = -3;
     //无锁状态
     0

四.ReentrantLock#unlock()

lock方法我们分析完了，下面我们来看看unlock方法做了些什么事。

1.ReentrantLock#unlock()

    public void unlock() {
        sync.release(1);
    }
    
    public final boolean release(int arg) {
        //这里先调用tryRelease尝试释放锁
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

2.ReentrantLock#tryRelease()

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            //释放锁的线程不是当前独占线程则抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //重新设置state值 如过state为0 当前独占线程设置为null
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

3.ReentrantLock#unparkSuccessor()

 private void unparkSuccessor(Node node) {
        //获取头节点的waitSatus
        int ws = node.waitStatus;
        if (ws < 0)
            node.compareAndSetWaitStatus(ws, 0);
        //找到头节点的下个节点
        Node s = node.next;
        //如果这个节点是null或者waitStatus>0
        //就从队列尾部开始找找到一个waitStatus < 0的节点
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node p = tail; p != node && p != null; p = p.prev)
                if (p.waitStatus <= 0)
                    s = p;
        }
        //通过LockSupport.unpark方法唤醒这个节点的线程
        if (s != null)
            LockSupport.unpark(s.thread);
    }

五.总结

至此，ReentrantLock的lock和unlock方法已经分析完了。做个小的总结。
1.ReentrantLock可以根据构造方法实现公平和非公平锁。
2.ReentrantLock是可重入的锁。
3.ReentrantLock的核心就是AQS，内部类Sync继承AQS提供了非公平和公平锁的实现，AQS通过一个state成员变量和一个双向队列来实现的。state代表是否有线程访问当前的临界资源，通过CAS算法保证其原子性，state为0表示没有线程访问临界区资源。双端队列中存储了封装了当前线程的Node节点，共有五种状态表示当前节点的状态，默认为0。如果当前lock线程没有获取到锁，则会把当前线程封装成Node节点，扔到双端队列中，此时并不会挂起这个线程，而是通过tryAcquire尝试获取锁，如果获取锁还是不成功，就根据当前节点的前驱节点的状态waitStatus来判断是否需要挂起当前线程。当线程主动释放锁的时候，到队列中找到一个waitStatus不为CANCELED的节点，并唤醒这个节点的线程。