基于JDK11从源码角度剖析可重入锁ReentrantLock的获取锁和解锁

最新推荐文章于 2024-08-17 17:45:31 发布

弯_弯

最新推荐文章于 2024-08-17 17:45:31 发布

阅读量319

点赞数

文章标签： java jvm 面试

本文链接：https://blog.csdn.net/tang_huan_11/article/details/127517757

版权

ReentrantLock是可重入的独占锁，同时只能有一个线程可以获取该锁，其他获取该锁的线程会被阻塞而被放入该锁的AQS阻塞队列里面。

ReentrantLock是JUC包提供的显式锁的一个基础实现类，实现了Lock接口。我们先来看下ReentrantLock的类图，如下：
在这里插入图片描述
从类图可知，ReentrantLock 是使用AQS来实现的，ReentrantLock 的构造函数根据参数来决定其内部是一个公平还是非公平锁，默认是非公平锁。构造函数代码如下：

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

获取锁原理

lock()方法

当一个线程调用lock()方法时，说明该线程希望获取该锁。如果锁当前没有被其他线程占用并且当前线程之前没有获取过该锁，则当前线程会获取到该锁，然后设置当前锁的拥有者为当前线程，并设置AQS的状态值为1，然后直接返回。如果当前线程之前已经获取过该锁，则这次只是简单地把AQS的状态值加1后返回。如果该锁已经被其他线程持有，则调用该方法的线程会被放入AQS队列后阻塞挂起。lock()方法源码如下：

 public void lock() {
        sync.acquire(1);
    }

从代码可知，lock()委托给了sync类，根据创建ReentrantLock构造函数选择sync的实现是NonfairSync还是FairSync，这个锁是一个非公平锁或者公平锁,最终调用的是AQS的acquire(）方法，代码如下：

   public final void acquire(int arg) {
        //step1:调用子类重写的tryAcquire（）方法，tryAcquire返回false会把当前线程放入AQS阻塞队列
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

我们先来看下非公平锁的tryAcquire(）方法实现,源码如下：

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

        /**
         * 非公平锁抢占的钩子方法
         * ReentrantLock“非公平”性体现在这里：如果占用锁的线程刚释放锁，state置为0，
         * 而排队等待锁的线程还未唤醒，新来的线程就直接抢占了该锁，那么就“插队”了。
         * 举一个例子，当前有三个线程A、B、C去竞争锁，假设线程A、B在排队，
         * 但是后来的C直接进行CAS操作成功了，拿到锁开开心心地返回了，那么线程A、B只能乖乖看着。
         * @param acquires
         * @return
         */
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
abstract static class Sync extends AbstractQueuedSynchronizer {
  

        /**
         * 核心思想是当前线程尝试获取锁的时候，如果发现锁的状态位是0，
         * 就直接尝试将锁拿过来，然后执行setExclusiveOwnerThread()，根本不管同步队列中的排队节点。
         */
        @ReservedStackAccess
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //先直接获得锁的状态
            int c = getState();
            //step2:当前AQS状态值为0
            if (c == 0) {
                // 如果内部队列首节点的线程执行完了，它会将锁的state设置为0，
                // 当前抢锁线程的下一步就是直接进行抢锁，不管不顾
                //返现state是空的，就直接拿来加锁使用，根本不考虑后面继承者的存在
                if (compareAndSetState(0, acquires)) {
                    //step1：利用CAS自旋方式判断当前state确实为0，然后设置为acquire（1），
                    // 这是原子性操作，保证线程安全
                    setExclusiveOwnerThread(current);
                    // 设置当前执行的线程，直接返回true
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {   //step3： 当前线程是该锁持有者
                //step2： 当前的线程和执行中的线程是同一个，也就意味着可重入操作
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                //表示当前锁被1个线程重复获取了nextc次
                return true;
            }  //step4：
            // 表示没有成功获取当前锁，进入排队过程
            return false;
        }    
        .....
}

在step2中会会查看当前锁的状态值是否为0，为0则说明当前该锁空闲，那么就尝试CAS获取该锁，将AQS的状态值从0设置为1，并设置当前锁的持有者为当前线程然后返回，true。如果当前状态值不为0则说明该锁已经被某个线程持有，所以step3查看当前线程是否是该锁的持有者，如果当前线程是该锁的持有者，则状态值加1，然后返回true，这里需要注意，nextc<0说明可重入次数溢出了。如果当前线程不是锁的持有者则返回false，然后其会被放入AQS阻塞队列。ReentrantLock 作为非公平锁时其抢占流程可以用下图表示：
在这里插入图片描述

介绍完ReentrantLock的非公平锁，接下来再来看看ReentrantLock的公平锁的tryAcquire ()策略，代码如下：

static final class FairSync extends Sync {
       
        /**
         * 公平抢占的钩子方法
         * 首先判断是否有后继节点，如果有后继节点，并且当前线程不是锁的占有线程，
         * 钩子方法就返回false，模板方法会进入排队的执行流程，可见公平锁是真正公平的。
         */
        @ReservedStackAccess
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //获取锁状态
            int c = getState();
            //step5： 当期AQS 状态值为0
            if (c == 0) {
                // step6：有后继接地那就返回，公平行策略
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
             // step7 :当前线程是该锁持有者
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

从代码可知，公平的tryAcquire策略与非公平的类似，不同之处在于，代码step6在设置CAS前添加了hasQueuedPredecessors方法，该方法是实现公平性的核心代码，代码如下:

    public final boolean hasQueuedPredecessors() {
        Node h, s;
        if ((h = head) != null) {
            if ((s = h.next) == null || s.waitStatus > 0) {
                s = null; // traverse in case of concurrent cancellation
                for (Node p = tail; p != h && p != null; p = p.prev) {
                    if (p.waitStatus <= 0)
                        s = p;
                }
            }
            if (s != null && s.thread != Thread.currentThread())
                return true;
        }
        return false;
    }

从代码可知，hasQueuedPredecessors的执行场景大致如下：
（ 1）如果(h = head) != null 不成立，说明头节点和尾节点要么是同一个节点，要么h头节点是null，此时hasQueuedPredecessors()返回false，表示没有后继节点。
（ 2）当(h = head) != null成立时，进一步检查head.next是否为null或者head.next的节点状态是否大于0，如果head.next为null或者head.next的节点状态大于0，head.next设置为null，然后查找是否有非头节点和非尾节点的线程处于等待状态的，有的话把head.next设置为正在等待的线程。
（ 3）当(h = head) != null成立时，head.next节点不为空且head.next不是当前线程时，就返回true，表示有后继节点，否则就返回false，表示没有后继节点。
ReentrantLock公平独占锁的抢占流程如下：
在这里插入图片描述

lockInterruptibly()方法

该方法与lock（）方法类似，它的不同在于，它对中断进行响应，就是当前线程在调用该方法时，如果其他线程调用了当前线程的interrupt（）方法，则当前线程会抛出InterruptedException异常，然后返回。


 public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
 public final void acquireInterruptibly(int arg)
            throws InterruptedException {
       // 如果当前线程被中断，则直接抛出异常
        if (Thread.interrupted())
            throw new InterruptedException();
       //尝试获取资源
        if (!tryAcquire(arg))
            //调用AQS可被中断的方法
            doAcquireInterruptibly(arg);
    }

释放锁原理

尝试释放锁，如果当前线程持有该锁，则调用该方法会让该线程对该线程持有的AQS状态值减1，如果减去1后当前状态值为0，则当前线程会释放该锁，否则仅仅减1而已。如果当前线程没有持有该锁而调用了该方法则会抛出IllegalMonitorStateException异常，代码如下：

 public void unlock() {
        sync.release(1);
}
public final boolean release(int arg) {
   if (tryRelease(arg)) { //释放锁的钩子方法的实现
       //队列头节点
       Node h = head;
       if (h != null && h.waitStatus != 0)
          //唤醒后继线程
           unparkSuccessor(h);
       return true;
   }
   return false;
}