深入理解并发编程-AQS(队列同步器)

客官°小女子只卖身不卖艺 2023-05-22 12:28 2阅读 0赞

> 本文为读书笔记,书籍为Java并发编程的艺术

### 文章目录 ###

*  1. Lock接口
 *  2. AbstractQueuedSynchronizer(AQS)
 *   *  AQS接口
     *   *  同步队列实现分析
         *   *  1.同步队列(FIFO双向队列)
             *  2.独占式同步状态获取与释放
             *  3.共享式同步状态获取与释放
             *  4.独占式超时获取同步状态
             *  5.自定义同步组件——TwinsLock
 *  3. 重入锁(ReentrantReadWriteLock)
 *  4. 读写锁
 *   *   *  读写锁的接口与示例
         *  读写锁的实现分析
         *   *  1.读写状态的设计
             *  2.写锁的获取与释放
             *  3.读锁的获取与释放
             *  4.锁降级
 *  5. LockSupport工具
 *  6. Condition接口
 *   *   *   *  Condition的实现分析(同步器的内部类)
             *   *  1.等待队列
                 *  2.等待
                 *  3.通知
 *  7. 总结

# 1. Lock接口 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]  
在finally块中释放锁，目的是保证在获取到锁之后，最终能够被释放。

不要将获取锁的过程写在try块中，因为如果在获取锁（自定义锁的实现）时发生了异常，异常抛出的同时，也会导致锁无故释放。

**与synchronized相比:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][20200417195034549.png]

# 2. AbstractQueuedSynchronizer(AQS) #

AQS主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态

同步状态的修改依赖于以下三个方法:

getState()
    setState(int newState)
    compareAndSetState(int expect, int update)

这三者它们能够保证状态的改变是安全的

锁和同步器(AQS)的关系:  
锁是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程并行访问），隐藏了实现细节；

同步器面向的是锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。

## AQS接口 ##

访问修改状态方法:

❑ getState()：获取当前同步状态。  
❑ setState(int newState)：设置当前同步状态。  
❑ compareAndSetState(int expect, int update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性。

可重写方法:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 2]

模板方法:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 3]  
同步器提供的模板方法基本上分为3类：独占式获取与释放同步状态、共享式获取与释放同步状态和查询同步队列中的等待线程情况。自定义同步组件将使用同步器提供的模板方法来实现自己的同步语义。

### 同步队列实现分析 ###

#### 1.同步队列(FIFO双向队列) ####

当前线程获取同步状态失败时，同步器会将当前线程以及等待状态等信息构造成为一个节点（Node）并将其加入同步队列**尾部**，同时会**阻塞当前线程**，当同步状态释放时，会把首节点中的线程唤醒，使其再次尝试获取同步状态。

节点属性如下:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 4]  
加入队列的过程必须要保证线程安全,因此同步器提供了一个基于CAS的设置尾节点的方法：**compareAndSetTail(Node expect, Node update)**，它需要传递当前线程“认为”的尾节点和当前节点，只有设置成功后，当前节点才正式与之前的尾节点建立关联。

首节点是获取同步状态成功的节点，**首节点的线程在释放同步状态时，将会唤醒后继节点**，而后继节点将会在获取同步状态成功时将自己设置为首节点

#### 2.独占式同步状态获取与释放 ####

获取同步状态:

public final void acquire(int arg) { 
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

private Node addWaiter(Node mode) { 
            Node node = new Node(Thread.currentThread(), mode);
            // Try the fast path of enq; backup to full enq on failure
            Node pred = tail;
            if (pred != null) { 
                node.prev = pred;
                if (compareAndSetTail(pred, node)) { 
                    pred.next = node;
                    return node;
                }
            }
            enq(node);
            return node;
        }

private Node enq(final Node node) { 
            for (;;) { 
                Node t = tail;
                if (t == null) {  // Must initialize
                    if (compareAndSetHead(new Node()))
                        tail = head;
                } else { 
                    node.prev = t;
                    if (compareAndSetTail(t, node)) { 
                        t.next = node;
                        return t;
                    }
                }
            }
        }

首先调用自定义同步器实现的tryAcquire(int arg)方法，该方法保证线程安全的获取同步状态，如果**同步状态获取失败**，则构造同步节点（独占式Node. EXCLUSIVE，同一时刻只能有一个线程成功获取同步状态）并通过addWaiter(Node node)方法将该节点加入到同步队列的尾部，最后调用acquireQueued(Node node, int arg)方法，使得该节点以“**死循环**”的方式获取同步状态。如果获取不到则阻塞节点中的线程，而被阻塞线程的唤醒主要依靠前驱节点的出队或阻塞线程被中断来实现。

**即如果获取同步状态失败,就以死循环的方法讲当前线程以节点的方式加入队列尾端**

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);
                        p.next = null; // help GC
                        failed = false;
                        return interrupted;
                    }
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally { 
                if (failed)
                    cancelAcquire(node);
            }
        }

在加入队列以后  
于此同时非头节点的节点在不断的进行**自旋**检查自己的前驱是不是头结点,如果是则尝试获取同步状态;  
为什么要这么做呢?  
**第一，头节点是成功获取到同步状态的节点，而头节点的线程释放了同步状态之后，将会唤醒其后继节点，后继节点的线程被唤醒后需要检查自己的前驱节点是否是头节点。  
第二，维护同步队列的FIFO原则。**

独占式同步状态获取流程:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 5]

#### 3.共享式同步状态获取与释放 ####

**共享与独占的区别:在于同一时刻能否有多个线程同时获取到同步状态。**

public final void acquireShared(int arg) { 
            if (tryAcquireShared(arg) < 0)
                doAcquireShared(arg);
        }

private void doAcquireShared(int arg) { 
            final Node node = addWaiter(Node.SHARED);
            boolean failed = true;
            try { 
                boolean interrupted = false;
                for (;;) { 
                    final Node p = node.predecessor();
                    if (p == head) { 
                        int r = tryAcquireShared(arg);
                        if (r >= 0) { 
                            setHeadAndPropagate(node, r);
                            p.next = null; // help GC
                            if (interrupted)
                                selfInterrupt();
                            failed = false;
                            return;
                        }
                    }
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally { 
                if (failed)
                    cancelAcquire(node);
            }
        }

在acquireShared(int arg)方法中，同步器调用tryAcquireShared(int arg)方法尝试获取同步状态，**tryAcquireShared(int arg)方法返回值为int类型，当返回值大于等于0时，表示能够获取到同步状态**。因此，在共享式获取的自旋过程中，成功获取到同步状态并退出自旋的条件就是tryAcquireShared(int arg)方法返回值大于等于0。可以看到，**在doAcquireShared(int arg)方法的自旋过程中，如果当前节点的前驱为头节点时，尝试获取同步状态，如果返回值大于等于0，表示该次获取同步状态成功并从自旋过程中退出。**

#### 4.独占式超时获取同步状态 ####

private boolean doAcquireNanos(int arg, long nanosTimeout)
                throws InterruptedException { 
            if (nanosTimeout <= 0L)
                return false;
            final long deadline = System.nanoTime() + nanosTimeout;
            final Node node = addWaiter(Node.EXCLUSIVE);
            boolean failed = true;
            try { 
                for (;;) { 
                    final Node p = node.predecessor();
                    if (p == head && tryAcquire(arg)) { 
                        setHead(node);
                        p.next = null; // help GC
                        failed = false;
                        return true;
                    }
                    nanosTimeout = deadline - System.nanoTime();
                    if (nanosTimeout <= 0L)
                        return false;
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        nanosTimeout > spinForTimeoutThreshold)
                        LockSupport.parkNanos(this, nanosTimeout);
                    if (Thread.interrupted())
                        throw new InterruptedException();
                }
            } finally { 
                if (failed)
                    cancelAcquire(node);
            }
        }

通过调用同步器的doAcquireNanos(int arg, long nanosTimeout)方法可以超时获取同步状态，即在指定的时间段内获取同步状态，如果获取到同步状态则返回true，否则，返回false。  
即doAcquireNanos(int arg, long nanosTimeout)会使当前线程等待nanosTimeout纳秒，如果当前线程在nanosTimeout纳秒内没有获取到同步状态，将会从等待逻辑中自动返回。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 6]

#### 5.自定义同步组件——TwinsLock ####

该工具在同一时刻，只允许至多两个线程同时访问，超过两个线程的访问将被阻塞，我们将这个同步工具命名为TwinsLock。  
TwinsLock能够在同一时刻支持多个线程的访问，这显然是共享式访问;  
表明同步资源数为2，这样可以设置初始状态status为2，当一个线程进行获取，status减1，该线程释放，则status加1，状态的合法范围为0、1和2，其中0表示当前已经有两个线程获取了同步资源，此时再有其他线程对同步状态进行获取，该线程只能被阻塞。在同步状态变更时，需要使用compareAndSet(int expect, int update)方法做原子性保障。

public class TwinsLock implements Lock { 
        private final Sync sync = new Sync(2);
    
        public static void main(String[] args) throws InterruptedException { 
            final Lock lock = new TwinsLock();
            class worker extends Thread { 
                @Override
                public void run() { 
                    while (true) { 
                        lock.lock();
                        try { 
                            Thread.sleep(1000);
                            System.out.println(Thread.currentThread().getName());
                            Thread.sleep(1000);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        } finally { 
                            lock.unlock();
                        }
                    }
                }
            }
            for (int i = 0; i <10 ; i++) { 
                worker worker=new worker();
                worker.setDaemon(true);
                worker.start();
            }
            for (int i = 0; i <10 ; i++) { 
                Thread.sleep(1000);
                System.out.println();
            }
        }
    
        @Override
        public void lock() { 
            sync.acquireShared(1);
        }
    
        @Override
        public void lockInterruptibly() throws InterruptedException { 
    
        }
    
        @Override
        public boolean tryLock() { 
            return false;
        }
    
        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { 
            return false;
        }
    
        @Override
        public void unlock() { 
            sync.releaseShared(1);
        }
    
        @Override
        public Condition newCondition() { 
            return null;
        }
    
        private static final class Sync extends AbstractQueuedSynchronizer { 
            Sync(int count) { 
                if (count < 0) { 
                    throw new IllegalArgumentException(" tai xiao l ");
                }
                setState(count);
            }
    
            @Override
            protected int tryAcquireShared(int reduceCount) { 
                for (; ; ) { 
                    int current = getState();
                    int newCount = current - reduceCount;
                    if (newCount < 0 || compareAndSetState(current, newCount)) { 
                        return newCount;
                    }
                }
            }
    
            @Override
            protected boolean tryReleaseShared(int returenCount) { 
                for (; ; ) { 
                    int current = getState();
                    int newCount = current + returenCount;
                    if (compareAndSetState(current, newCount)) { 
                        return true;
                    }
                }
            }
        }
    
    }

> 解释一下 Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。

# 3. 重入锁(ReentrantReadWriteLock) #

如何实现?  
1）线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。

2）锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。

[可见另外一篇分析ReentrantLock][ReentrantLock]

公平性锁保证了锁的获取按照FIFO原则，而代价是进行大量的线程切换。非公平性锁虽然可能造成线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。

# 4. 读写锁 #

> 读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。

### 读写锁的接口与示例 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 7]  
使用:  
![在这里插入图片描述][20200417220351440.png]

### 读写锁的实现分析 ###

#### 1.读写状态的设计 ####

**很容易就分析出来,读状态就是共享状态,写状态就是独占状态**  
读写锁的自定义同步器需要在同步状态（一个整型变量）上维护多个读线程和一个写线程的状态，使得该状态的设计成为读写锁实现的关键。

那么如何通过state来辨别这些状态呢?  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 8]  
按位来划分;int 4字节,32位  
假设当前同步状态值为S，写状态等于S&0x0000FFFF（将高16位全部抹去），读状态等于S>>>16（无符号补0右移16位）。当写状态增加1时，等于S+1，当读状态增加1时，等于S+(1<<16)，也就是S+0x00010000。  
根据状态的划分能得出一个推论：**S不等于0时，当写状态（S & 0x0000FFFF）等于0时，则读状态（S>>>16）大于0，即读锁已被获取。**

#### 2.写锁的获取与释放 ####

写锁是一个支持重进入的排它锁。如果当前线程已经获取了写锁，则增加写状态。如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程，则当前线程进入等待状态

protected final boolean tryAcquire(int acquires) { 
              // 1。如果读计数非零或写计数非零
    			// *和所有者是不同的线程，失败。
    			// * 2。如果计数饱和，则失败。(这只能
    			// *如果count已经非零，则发生。)
    			//* 3。否则，此线程将被锁定
    			// *它要么是可重入收购，要么是
    			// *队列策略允许。如果是，则更新状态
    			// *和setowner。
                Thread current = Thread.currentThread();
                int c = getState();
                int w = exclusiveCount(c);
                if (c != 0) { 
                 //存在读锁或者当前线程已经不是获取到写锁的进程
                    if (w == 0 || current != getExclusiveOwnerThread())
                        return false;
                    if (w + exclusiveCount(acquires) > MAX_COUNT)
                        throw new Error("Maximum lock count exceeded");
                    // Reentrant acquire
                    setState(c + acquires);
                    return true;
                }
                if (writerShouldBlock() ||
                    !compareAndSetState(c, c + acquires))
                    return false;
                setExclusiveOwnerThread(current);
                return true;
            }

果允许读锁在已被获取的情况下对写锁的获取，那么正在运行的其他读线程就无法感知到当前写线程的操作。因此，只有等待其他读线程都释放了读锁，写锁才能被当前线程获取，而写锁一旦被获取，则其他读写线程的后续访问均被阻塞。

#### 3.读锁的获取与释放 ####

读锁是一个支持重进入的**共享锁**，它能够被多个线程同时获取，在没有其他写线程访问（或者写状态为0）时，读锁总会被成功地获取，而所做的也只是（线程安全的）增加读状态。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已被其他线程获取，则进入等待状态。

protected final int tryAcquireShared(int unused) { 
                /* * 介绍:* 1。如果另一个线程持有写锁，则失败。 * 2。否则，这个线程有资格进入* lock wrt状态， * 所以询问它是否应该因为队列策略而阻塞*。 * 如果不是，尝试授予通过肠衣状态和更新计数。 * 注意，步骤不检查重入*获取，它被推迟到完整版本 *，以避免在*更典型的不可重入情况下检查持有计数。 3。如果第2步失败，要么是因为线程*显然不符合条件， 要么是CAS失败，要么是count *饱和，那么用完整的 重试循环链接到版本。 */
                Thread current = Thread.currentThread();
                int c = getState();
                if (exclusiveCount(c) != 0 &&
                    getExclusiveOwnerThread() != current)
                    return -1;
                int r = sharedCount(c);
                if (!readerShouldBlock() &&
                    r < MAX_COUNT &&
                    compareAndSetState(c, c + SHARED_UNIT)) { 
                    if (r == 0) { 
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) { 
                        firstReaderHoldCount++;
                    } else { 
                        HoldCounter rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current))
                            cachedHoldCounter = rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                    }
                    return 1;
                }
                return fullTryAcquireShared(current);
            }

#### 4.锁降级 ####

锁降级是指把\*\*持住（当前拥有的）写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。\*\*而不是,先获取写锁,释放,再获取读锁;

# 5. LockSupport工具 #

LockSupport定义了一组以park开头的方法用来**阻塞**当前线程，以及unpark(Thread thread)方法来唤醒一个被阻塞的线程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 9]

# 6. Condition接口 #

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

Condition对象是由Lock对象（调用Lock对象的newCondition()方法）创建出来的，换句话说，Condition是依赖Lock对象的。

部分方法值:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 11]

#### Condition的实现分析(同步器的内部类) ####

每个Condition对象都包含着一个队列（以下称为等待队列），该队列是Condition对象实现等待/通知功能的关键。

##### 1.等待队列 #####

等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，**该线程就是在Condition对象上等待的线程**，如果一个线程调用了Condition.await()方法，那么该**线程将会释放锁、构造成节点**加入等待队列并进入等待状态。  
![在这里插入图片描述][20200418160624448.png]  
**在Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而并发包中的Lock（更确切地说是同步器）拥有一个同步队列和多个等待队列**

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

##### 2.等待 #####

调用Condition的await()方法（或者以await开头的方法），会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。当从await()方法返回时，当前线程一定获取了Condition相关联的锁。

public final void await() throws InterruptedException { 
                if (Thread.interrupted())
                    throw new InterruptedException();
                    //当前线程加入等待队列
                Node node = addConditionWaiter();
                //释放同步状态
                int savedState = fullyRelease(node);
                int interruptMode = 0;
                while (!isOnSyncQueue(node)) { 
                    LockSupport.park(this);
                    if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                        break;
                }
                if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                    interruptMode = REINTERRUPT;
                if (node.nextWaiter != null) // clean up if cancelled
                    unlinkCancelledWaiters();
                if (interruptMode != 0)
                    reportInterruptAfterWait(interruptMode);
            }

##### 3.通知 #####

调用Condition的signal()方法，将会唤醒在等待队列中**等待时间最长**的节点（首节点），在**唤醒节点之前，会将节点移到同步队列**中。

public final void signal() { 
                if (!isHeldExclusively())
                    throw new IllegalMonitorStateException();
                Node first = firstWaiter;
                if (first != null)
                    doSignal(first);
            }

调用该方法的前置条件是**当前线程必须获取了锁**，可以看到signal()方法进行了isHeldExclusively()检查，也就是当前线程必须是获取了锁的线程。接着获取等待队列的首节点，将其移动到同步队列并使用LockSupport唤醒节点中的线程。

# 7. 总结 #

这一部分还是很难的  
但是总体来说,AQS就是基于Volatile和CAS的锁的实现形式  
一般的自定义实现方式就是要 在自己实现的类里实现内部类sync  
详情可见2.x.5 自定义同步组件-TwinsLock

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]: /images/20230521/d2e69e98156b48ce9ad46bbed482c569.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]: /images/20230521/35926d6fc4e84073808342ad19171deb.png
[20200417195034549.png]: /images/20230521/d29ce65a1ce74c04a8f618b768ee436b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 2]: /images/20230521/ad09a27ca0ef436d960e479b2b09182f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 3]: /images/20230521/836d4dc2d936419a972aba47d9758cb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 4]: /images/20230521/5f126549fc5d47dfae3aa6039c4a5ff9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 5]: /images/20230521/a2627b4ba19942beab99a497a4658a2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 6]: /images/20230521/a8b6eb53b447494f97157184cdf6c053.png
[ReentrantLock]: https://blog.csdn.net/littlewhitevg/article/details/105584195
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 7]: /images/20230521/0b9183633d5240bc9a94ae0bacaad4e5.png
[20200417220351440.png]: /images/20230521/0927bac0e56c4f5ea01b7eb24b85bc58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 8]: /images/20230521/cfb974d8204843738091a74a2190a320.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 9]: /images/20230521/eac476be49f74f87a338ee5f73c473a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 10]: /images/20230521/8f3e8d52307f4dd2964a8212a57399ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 11]: /images/20230521/7c5a7dc88b3d4075b9701a48c43e6d46.png
[20200418160624448.png]: /images/20230521/08b6c231c14944fabff823be54e64378.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 12]: /images/20230521/80de618b8a1a478e9ae3a468fa621558.png