ReentrantLock源码解析_we don‘t need to do so to check if current thread (1)

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前在阿里

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上运维知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以点击这里获取！

ReentrantLock简介：重入锁ReetrantLock，实现了Lock接口，作用与synchronized关键字相当，但比synchronized更加灵活。ReetrantLock本身也是一种支持重进入的锁，即该锁可以支持一个线程对资源重复加锁，同时也支持公平锁与非公平锁。所谓的公平与非公平指的是在请求先后顺序上，先对锁进行请求的就一定先获取到锁，那么这就是公平锁，反之，如果对于锁的获取并没有时间上的先后顺序，如后请求的线程可能先获取到锁，这就是非公平锁，一般而言非，非公平锁机制的效率往往会胜过公平锁的机制，但在某些场景下，可能更注重时间先后顺序，那么公平锁自然是很好的选择。需要注意的是ReetrantLock支持对同一线程重加锁，但是加锁多少次，就必须解锁多少次，这样才可以成功释放锁。

ReentrantLock实现了Lock接口。但是底层锁机制是通过AQS实现的。ReentrantLock有一个内部类Sync是继承了AQS 源码如下

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        //锁对象
        abstract void lock();

        //非公平锁获取锁资源
        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;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // Methods relayed from outer class

        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }

        /**
         * Reconstitutes the instance from a stream (that is, deserializes it).
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

非公平锁NonfairSync的实现

在ReentrantLock还有两个内部类其中一个就是NonfairSync他继承了抽象类Sync

  static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        
        //非公平锁的具体实现
        final void lock() {
            // CAS比较state变量值 去更改state的值为1 尝试去获取锁
            if (compareAndSetState(0, 1))
                //获取锁成功。成功则将独占锁线程设置为当前线程  
                setExclusiveOwnerThread(Thread.currentThread());
            else
                // 失败的情况下、 再次请求同步状态
                acquire(1);
        }

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

    //AQS 中的方法 尝试获取锁
    public final void acquire(int arg) {
         // tryAcquire(arg) 获取锁成功为true 否则为false
        if (!tryAcquire(arg) &&
            // addWaiter 在同步队列中的队尾新增一条数据
   
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

             
            selfInterrupt();
    }

    //AQS 中的方法 尝试获取锁
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            一直循环
            for (;;) {
                  // 获取当前节点的前置节点
                final Node p = node.predecessor();
                
                if (p == head && tryAcquire(arg)) {
                     //获取前置节点为头部节点，并且头部节点已经获取锁了
                     // 设置头部节点为当前接口
                    setHead(node);
                    // 并将已经获取锁的节点的后驱节点置为null 便于垃圾回收
                    p.next = null;
                    failed = false;
                    return interrupted;
                }
                //响应中断 判断当前节点的前置节点是否为头部接口并且当前节点的线程是否被中断 
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            //获取锁失败。那么就会取消获取锁。将node节点的状态置为cancel取消状态
            if (failed)
                cancelAcquire(node);
        }
    }


acquire具体的实现逻辑在sync的nonfairTryAcquire方法
         final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 尝试获取state状态
            int c = getState();
            // 如果state 说明资源没有被占用


### 最后的话

最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！

### 资料预览

给大家整理的视频资料：

![](https://img-blog.csdnimg.cn/img_convert/52273df9b0b1e91a12606374bb9c1f30.png)

给大家整理的电子书资料：

  

![](https://img-blog.csdnimg.cn/img_convert/7441b66cbdaa3e2723b46fb7c0669188.png)



**如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！**

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以点击这里获取！](https://bbs.csdn.net/topics/618542503)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以点击这里获取！](https://bbs.csdn.net/topics/618542503)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**