ReentrantLock类的实现原理

以你之姓@ 2022-10-20 05:24 176阅读 0赞

## 一、简介 ##

*  ReentrantLock是Java并发包中提供的一个可重入的互斥锁。ReentrantLock和synchronized在基本用法，行为语义上都是类似的，同样都具有可重入性。只不过相比原生的Synchronized，ReentrantLock增加了一些高级的扩展功能，比如它可以实现公平锁，同时也可以绑定多个Conditon。
 *  ReentrantLock是基于AQS的，AQS是Java并发包中众多同步组件的构建基础，它通过一个int类型的状态变量state和一个FIFO队列来完成共享资源的获取，线程的排队等待等。AQS是个底层框架，采用模板方法模式，它定义了通用的较为复杂的逻辑骨架，比如线程的排队，阻塞，唤醒等，将这些复杂但实质通用的部分抽取出来，这些都是需要构建同步组件的使用者无需关心的，使用者仅需重写一些简单的指定的方法即可（其实就是对于共享变量state的一些简单的获取释放的操作）。

## 二、原理实现 ##

##### 1、构造函数 #####

//sync是ReentrantLock内部实现的一个同步组件，它是Reentrantlock的一个静态内部类，
    继承于AQS
    //默认构造函数为非公平锁
        public ReentrantLock() {
        
            sync = new NonfairSync();
        }
    //可通过boolean参数来设置为公平锁或非公平锁
     	public ReentrantLock(boolean fair) {
        
            sync = fair ? new FairSync() : new NonfairSync();
        }

##### 2、常用方法 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70]

##### 3、静态内部类之非公平锁 #####

总体流程思路：

1.  先获取state值，若为0，意味着此时没有线程获取到资源，CAS将其设置为1，设置成功则代表获取到排他锁了；
2.  若state大于0，肯定有线程已经抢占到资源了，此时再去判断是否就是自己抢占的，是的话，state累加，返回true，重入成功，state的值即是线程重入的次数；
3.  其他情况，则获取锁失败。

static final class NonfairSync extends Sync {
        
            private static final long serialVersionUID = 7316153563782823691L;
    
            /**
             * Performs lock.  Try immediate barge, backing up to normal
             * acquire on failure.
             */
            final void lock() {
        
                if (compareAndSetState(0, 1))//CAS去设置值，期望值为0，设置为1
                    setExclusiveOwnerThread(Thread.currentThread());//将当前线程标记为已持有锁
                else
                    acquire(1);
                 /*若设置失败，调用AQS的acquire方法，acquire又会调用我们下面重写
                 tryAcquire方法。这里说的调用失败有两种情况：1当前没有线程获取到资源，
                 state为0，但是将state由0设置为1的时候，其他线程抢占资源，将state修改
                 了，导致了CAS失败；2 state原本就不为0，也就是已经有线程获取到资源了，
                 有可能是别的线程获取到资源，也有可能是当前线程获取的，这时线程又重复去获
                 取，所以去tryAcquire中的nonfairTryAcquire我们应该就能看到可重入的实现
                 逻辑了。*/
            }
    
            protected final boolean tryAcquire(int acquires) {
        
                return nonfairTryAcquire(acquires);//调用Sync中的方法
            }
        }

sync内部静态类的nofairTryAcquire（）

final boolean nonfairTryAcquire(int acquires) {
        
                final Thread current = Thread.currentThread();//获取当前线程
                int c = getState();//获取当前的状态值
                if (c == 0) {
        //若state为0，意味着没有线程获取到资源，CAS将state设置
    为1，并将当前线程标记我获取到排他锁的线程，返回true
     
                    if (compareAndSetState(0, acquires)) {
        
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {
        
    //如果state不为0，说明已经有线程获取到该资源，如果获取到该资源的线程为当前线程，那
    么，当前线程可实现锁的可重入
                    int nextc = c + acquires;//state累加1
                    if (nextc < 0) //int类型越界处理
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);//保存状态，实现可重入
                    return true;//返回true，获取锁成功
                }
                return false;//获取锁失败
            }

##### 4、静态内部类之公平锁 #####

公平锁的大致逻辑与非公平锁是一致的，不同的地方在于有了!hasQueuedPredecessors()这个判断逻辑，即便state为0，也不能贸然直接去获取，要先去看有没有还在排队的线程，若没有，才能尝试去获取，做后面的处理。反之，返回false，获取失败。

static final class FairSync extends Sync {
        
            private static final long serialVersionUID = -3000897897090466540L;
    
            final void lock() {
        
    //直接调用AQS的模板方法acquire，acquire会调用下面我们重写的这个tryAcquire
                acquire(1);
            }
    
            /**
             * Fair version of tryAcquire.  Don't grant access unless
             * recursive call or no waiters or is first.
             */
            protected final boolean tryAcquire(int acquires) {
        
                final Thread current = Thread.currentThread();//获取当前线程
                int c = getState();//获取当前状态
                if (c == 0) {
        //如果状态为0
    //判断在时间顺序上，是否有申请锁排在自己之前的线程，若没有，才能去获取，CAS设置
    //state，并标记当前线程为持有排他锁的线程；反之，不能获取！这即是公平的处理方式。
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
        
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
    //如果state不为0，但当前线程是获得相应资源的线程实现可重入；
                else if (current == getExclusiveOwnerThread()) {
        
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;//重入锁成功
                }
                return false;//获取锁失败
            }
        }

//hasQueuedPredecessors是用来判断AQS的队列头的线程是否为当前线程，
    //如果不是，则返回true，此时当前线程遵循公平机制，不能抢占资源；
    //如果是，则返回false，此时当前贤臣位于队列头，可抢占资源；
        public final boolean hasQueuedPredecessors() {
        
            // The correctness of this depends on head being initialized
            // before tail and on head.next being accurate if the current
            // thread is first in queue.
            Node t = tail; // Read fields in reverse initialization order
            Node h = head;
            Node s;
            return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
        }

释放相应的锁

protected final boolean tryRelease(int releases) {
        
                int c = getState() - releases;//减去1个资源
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                //若state值为0，表示当前线程已完全释放干净，返回true，上层的AQS会意识到资源已空出。若不为0，则表示线程还占有资源，只不过将此次重入的资源的释放了而已，返回false。
                if (c == 0) {
        
                    free = true;//
                    setExclusiveOwnerThread(null);
                }
                setState(c);
                return free;
            }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70]: /images/20221020/6d5e8432656c43d19713721f5543d141.png