ReentrantLock学习（二）类整体结构及核心方法时序

小鱼儿 2021-10-19 11:00 245阅读 0赞

### 一、整体结构 ###

ReentrantLock的核心实际为 AbstractOwnableSynchronizer，简称AQS

>  *  **Lock**：锁接口类，定义了锁的一些基本方法
>  *  **ReentrantLock**：其锁的实现依赖于内部sync
>  *  **Sync**：ReentrantLock的内部类，继承了AQS，实现了部分模板方法
>  *  **NonfairSync**：ReentrantLock的内部类，继承了Sync，ReentrantLock非公平锁的实现，也是默认ReentrantLock的默认锁
>  *  **FairSync**：ReentrantLock的内部类，也继承了Sync，ReentrantLock公平锁的实现，构造时需传入参数true进行创
>  *  **AbstractOwnableSynchronizer**：主要提供记录持有锁线程的方法
>  *  **AbstractQueuedSynchronizer**：简称AQS，提供了一个同步器队列链表，同步状态以及一系列模板方法，如tryAcquire、tryRelease、tryAcquireShared、tryReleaseShared、isHeldExclusively等
>  *  **Node**：AQS内部类，链表
>  *  **Condition**：定义了Condition的相关方法，如await、signal
>  *  **ConditionObject**：AQS内部类，实现了Condition接口，内部维护了一个等待队列链表
>  *  **LockSupport**：提供了park、unpark等方法，来挂起、唤醒线程（下图未体现是因为该类提供的静态方法）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhb3hpbGFveGlf_size_16_color_FFFFFF_t_70][]

### 二、核心方法时序 ###

下图是以ReentrantLock的非公平锁为例，与整体与公平锁相差不是很多。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhb3hpbGFveGlf_size_16_color_FFFFFF_t_70 1][]

***ps：内部方法解析之后文章分析***

### 三、个人思考 ###

Condition 与 Lock是如何建立联系的？为什么Condition可以使锁挂起，可以唤醒锁？

> 其中，有个类结构比较巧妙
> 
> 以AQS为核心，ConditionObject为AQS的内部类，且实现了Condition接口，那么由ConditionObject构造的Condition对象，则可以使用AQS的方法及属性，而ReentrantLock的核心是内部持有一个Sync的对象，而这个Sync的类继承了AQS，锁功能的实现依赖于AQS内部的状态及链表的记录，那么Condition则可以调用使用其外部类（AQS）的属性（链表及状态）以及方法（本身的方法及子类实现的方法）来控制当前锁线程的挂起及唤醒。
> 
> 内部类对象的创建需要起外部类对象进行调用，创建出来的内部类对象持有外部类对象的引用，这样再加上java的继承，就可以建立看似不太相关的两个类，其实已经建立了联系。（其实对于一些大神来说，这个用法不算啥，但本人理解这块稍稍花了些时间，特此记录一下）

例如

//内部类的interface，类似于Condition
    public interface Inner {
    
        int getValue();
    
        void add(int value);
    
    }
    //外部类的抽象类，含一内部类InnerImpl，类似以AQS
    public abstract class Father {
    
        protected int value;
    
        class InnerImpl implements Inner {
            @Override
            public int getValue() {
                return value;
            }
    
            @Override
            public void add(int v) {
                value+=v;
            }
        }
    }
    //外部类的具体实现，集成了外部类的抽象类，类似于ReentrantLock.Sync
    public class Outer extends Father {
    
        Outer(int value) {
            this.value = value;
        }
    
        public Outer(){
            this.value = 0;
        }
    
        Inner getInner(){
            return new InnerImpl();
        }
    
        public int getValue(){
            return this.value;
        }
    
        public void setValue(int v){
            this.value = v;
        }
    }
    //main方法
    public static void main(String[] args) {
        //构建outer，并设置值
        Outer outer = new Outer(111111);
        //通过outer创建inner
        Inner inner = outer.getInner();
        //inner获取值
        System.out.println(inner.getValue());
        //outer重设值
        outer.setValue(1);
        //inner获取值
        System.out.println(inner.getValue());
        //inner修改值
        inner.add(10);
        outer获取值
        System.out.println(outer.getValue());
    }

执行结果

111111
    1
    11

可以看到，双方在Father内部建立了两个对象的联系，也就是变相实现“双继承”的方式（java不支持类的多集成）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhb3hpbGFveGlf_size_16_color_FFFFFF_t_70]: /images/20211018/1c23ed879e99427fbfe43c81d8ed7797.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhb3hpbGFveGlf_size_16_color_FFFFFF_t_70 1]: /images/20211018/e3a0c565100a4fb984c19d97f412b283.png