并发编程 - 深入解析 ConcurrentHashMap

我们都知道在高并发下 `ArrayList` 是线程不安全的，那如果要使用集合要如何处理呢？接下来即将深入探讨Java并发容器中的 `CopyOnWriteArrayList`。见名知义，包含 `Array` 的底层还是通过数组实现的，这种特别适合读多写少的并发环境，接下来我们去深入了解下 `CopyOnWriteArrayList` 是如何能在高并发下保证数据的一致性的。




## CopyOnWriteArrayList

`CopyOnWriteArrayList`（COW）是一个线程安全的 `ArrayList`，采用 **"写时复制"** 思想，实现了读操作完全无锁的高性能并发容器。


### 核心设计思想

`CopyOnWriteArrayList` 是基于 `ReentrantLock` 锁和 **创建数组副本** 的形式去保证线程安全。

**读取**
读取：直接访问当前数组，无需加锁


**写入**

在写数据时，先获取 `lock` 锁，复制原数组创建一个副本数组，在新数组上执行修改操作，将副本数组赋值给`CopyOnWriteArrayList` 中的 `array`（因为是 `volatile` 的，原子替换引用指向新数组）。


**写操作性能开销（内存复制 + GC压力）**

因为 `CopyOnWriteArrayList` 每次写数据都要构建一个副本，如果你的业务是写多，并且数组中的数据量比较大，尽量避免去使用 `CopyOnWriteArrayList`，因为这里会构建大量的数组副本，比较占用内存资源。

`CopyOnWriteArrayList` 是弱一致性的，写操作先执行，在副本还没有落到 `CopyOnWriteArrayList` 的`array` 属性中，此时读操作是无法查询到的。

```java
// 伪代码演示COW机制
public void add(E element) {
    Object[] oldArray = currentArray;        // 1. 获取当前数组
    Object[] newArray = Arrays.copyOf(oldArray, oldArray.length + 1); // 2. 复制新数组
    newArray[newArray.length - 1] = element; // 3. 修改新数组
    currentArray = newArray;                 // 4. 原子替换引用
}
```

### 源码深度解析

主要查看2个核心属性，以及2个核心方法，还有无参构造

```java
/** 写操作时，需要先获取到的锁资源，CopyOnWriteArrayList 全局唯一的。 */
final transient ReentrantLock lock = new ReentrantLock();

/** 保证可见性的数组引用 （volatile保证写操作对其他线程立即可见）CopyOnWriteArrayList 真实存放数据的位置，查询也是查询当前array */
private transient volatile Object[] array;

// 获取当前数组属性
final Object[] getArray() {
    return array;
}

// 替换array属性
final void setArray(Object[] a) {
    array = a;
}

/**
 *  默认new的 CopyOnWriteArrayList 数组长度为0。
 *  不像ArrayList，初始长度是10，每次扩容1/2, CopyOnWriteArrayList不存在这个概念
 *  每次写的时候都会构建一个新的数组
 */
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}
```

:::tip{title="volatile + 锁的双重保障"}
- volatile 保证数组引用的可见性
- ReentrantLock 保证写操作的原子性
:::

#### 读操作

`CopyOnWriteArrayList` 的读操作就是 `get` 方法，基于数组索引位置获取数据。

方法之所以要差分成两个，是因为 `CopyOnWriteArrayList` 中在获取数据时，不单单只有一个 `array` 的数组需要获取值，还有副本中数据的值。

```java
// 查询数据时，只能通过get方法查询CopyOnWriteArrayList中的数据
public E get(int index) {
    // 直接访问当前数组，调用get方法的重载
    return get(getArray(), index);
}
// 执行get(int)时，内部调用的方法
private E get(Object[] a, int index) {
    // 直接拿到数组上指定索引位置的值，无锁读取数据
    return (E) a[index];
}
```

#### 写操作

`CopyOnWriteArrayList` 是基于 `lock` 锁和 **数组副本** 的形式保证线程安全。

```java
// 写入元素，不指定索引位置，直接放到最后的位置
public boolean add(E e) {
    // 获取全局锁，并执行lock
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取原数组，还获取了原数组的长度
        Object[] elements = getArray();
        int len = elements.length;
        // 基于原数组复制一份副本数组，并且长度比原来多了一个
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 将添加的数据放到副本数组最后一个位置
        newElements[len] = e;
        // 将副本数组，赋值给CopyOnWriteArrayList的原数组
        setArray(newElements);
        // 添加成功，返回true
        return true;
    } finally {
        // 释放锁~
        lock.unlock();
    }
}

// 写入元素，指定索引位置。（不会覆盖数据）
public void add(int index, E element) {
    // 拿锁，加锁~
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取原数组，还获取了原数组的长度
        Object[] elements = getArray();
        int len = elements.length;
        // 如果索引位置大于原数组的长度，或者索引位置是小于0的。
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+len);
        // 声明了副本数组
        Object[] newElements;
        // 原数组长度 - 索引位置等到numMoved
        int numMoved = len - index;
        // 如果numMoved为0，说明数据要放到最后面的位置
        if (numMoved == 0)
            // 直接走了原生态的方式，正常复制一份副本数组
            newElements = Arrays.copyOf(elements, len + 1);
        else {
            // 数组要插入的位置不是最后一个位置
            // 副本数组长度依然是原长度 + 1
            newElements = new Object[len + 1];
            // 将原数组从0索引位置开始复制，复制到副本数组中的前置位置
            System.arraycopy(elements, 0, newElements, 0, index);
            // 将原数组从index位置开始复制，复制到副本数组的index + 1往后放。
            // 这时，index就空缺出来了。
            System.arraycopy(elements, index, newElements, index + 1,
                             numMoved);
        }
        // 数据正常放到指定的索引位置
        newElements[index] = element;
        // 将副本数组，赋值给CopyOnWriteArrayList的原数组
        setArray(newElements);
    } finally {
        // 释放锁
        lock.unlock();
    }
}
```

#### 移除数据

关于 `remove` 操作，要分析两个方法

* 基于索引位置移除指定数据
* 基于具体元素删除数组中最靠前的数据
    1. 当前这种方式，嵌套了一层，导致如果元素存在话，成本是比较高的。
    2. 如果元素不存在，这种设计不需要加锁，提升写的效率

```java
// 删除指定索引位置的数据
public E remove(int index) {
    // 拿锁，加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取原数组和原数组长度
        Object[] elements = getArray();
        int len = elements.length;
        // 通过get方法拿到index位置的数据
        E oldValue = get(elements, index);
        // 声明numMoved
        int numMoved = len - index - 1;
        // 如果numMoved为0，说明删除的元素是最后的位置
        if (numMoved == 0)
            // Arrays.copyOf复制一份新的副本数组，并且将最后一个数据不要了
            // 基于setArray将副本数组赋值给array原数组
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            // 删除的元素不在最后面的位置
            // 声明副本数组，长度是原数组长度 - 1
            Object[] newElements = new Object[len - 1];
            // 从0开始复制的index前面
            System.arraycopy(elements, 0, newElements, 0, index);
            // 从index后面复制到最后
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        // 返回被干掉的数据
        return oldValue;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

// 删除元素（最前面的）
public boolean remove(Object o) {
    // 没加锁！！！！
    // 获取原数组
    Object[] snapshot = getArray();
    // 用indexOf获取元素在数组的哪个索引位置
    // 没找到的话，返回-1
    int index = indexOf(o, snapshot, 0, snapshot.length);
    // 如果index < 0,说明元素没找到，直接返回false，告辞
    // 如果找到了元素的位置，直接执行remove方法的重载
    return (index < 0) ? false : remove(o, snapshot, index);
}

// 执行remove(Object o)，找到元素位置时，执行当前方法
private boolean remove(Object o, Object[] snapshot, int index) {
    // 拿锁，加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 拿到原数组和长度
        Object[] current = getArray();
        int len = current.length;
        // findIndex: 是给if起标识，break 标识的时候，直接跳出if的代码块~~
        if (snapshot != current) findIndex: {
            // 如果没进到if，说明数组没变化，按照原来的index位置删除即可
            // 进到这，说明数组有变化，之前的索引位置不一定对
            // 拿到index位置和原数组长度的值
            int prefix = Math.min(index, len);
            // 循环判断，数组变更后，是否影响到了要删除元素的位置
            for (int i = 0; i < prefix; i++) {
                // 如果不相等，说明元素变化了。
                // 同时判断变化的元素是否是我要删除的元素o
                if (current[i] != snapshot[i] && eq(o, current[i])) {
                    // 如果满足条件，说明当前位置就是我要删除的元素
                    index = i;
                    break findIndex;
                }
            }
            // 如果for循环结束，没有退出if，说明元素可能变化了，总之没找到要删除的元素
            // 如果删除元素的位置，已经大于等于数组长度了。
            if (index >= len)
                // 超过索引范围了，没法删除了。
                return false;
            // 索引还在范围内，判断是否是还是原位置，如果是，直接跳出if代码块
            if (current[index] == o)
                break findIndex;
            // 重新找元素在数组中的位置
            index = indexOf(o, current, index, len);
            // 找到直接跳出if代码块
            // 没找到。执行下面的return false
            if (index < 0)
                return false;
        }
        // 删除套路，构建新数组，复制index前的，复制index后的
        Object[] newElements = new Object[len - 1];
        System.arraycopy(current, 0, newElements, 0, index);
        System.arraycopy(current, index + 1,
                         newElements, index,
                         len - index - 1);
        // 复制到array
        setArray(newElements);
        // 返回true，删除成功
        return true;
    } finally {
        lock.unlock();
    }
}
```

#### 覆盖数据 & 清空集合

覆盖数据就是 `set` 方法，可以将指定位置的数据替换

```java
// 覆盖数据
public E set(int index, E element) {
    // 拿锁，加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取原数组
        Object[] elements = getArray();
        // 获取原数组的原位置数据
        E oldValue = get(elements, index);

        // 原数据和新数据不一样
        if (oldValue != element) {
            // 拿到原数据的长度，复制一份副本。
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len);
            // 将element替换掉副本数组中的数据
            newElements[index] = element;
            // 写回原数组
            setArray(newElements);
        } else {
            // 原数据和新数据一样，啥不干，把拿出来的数组再写回去
            setArray(elements);
        }
        // 返回原值
        return oldValue;
    } finally {
        // 释放锁
        lock.unlock();
    }
}
```

清空就是清空了~~~

```java
public void clear() {
	// 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
		// 扔一个长度为0的数组
        setArray(new Object[0]);
    } finally {
        lock.unlock();
    }
}
```

#### 迭代器

用 `ArrayList` 时，如果想在遍历的过程中去移除或者修改元素，必须使用迭代器才可以。

即使写操作中原始数组被替换，迭代器仍访问旧数组，不让在迭代时做写操作是因为不希望迭代操作时，会影响到写操作，还有，不希望迭代时，还需要加锁。

```java
// 获取遍历CopyOnWriteArrayList的iterator。
public Iterator<E> iterator() {
    // 其实就是new了一个COWIterator对象，并且获取了array，指定从0开始遍历
    return new COWIterator<E>(getArray(), 0);
}

static final class COWIterator<E> implements ListIterator<E> {
    /** 遍历的快照 */
    private final Object[] snapshot;
    /** 游标，索引~~~ */
    private int cursor;

    // 有参构造
    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }

    // 有没有下一个元素，基于遍历的索引位置和数组长度查看
    public boolean hasNext() {
        return cursor < snapshot.length;
    }
    // 有没有上一个元素
    public boolean hasPrevious() {
        return cursor > 0;
    }

    // 获取下一个值，游标动一下
    public E next() {
        // 确保下个位置有数据
        if (! hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }

    // 获取上一个值，游标往上移动
    public E previous() {
        if (! hasPrevious())
            throw new NoSuchElementException();
        return (E) snapshot[--cursor];
    }

    // 拿到下一个值的索引，返回游标
    public int nextIndex() {
        return cursor;
    }

    // 拿到上一个值的索引，返回游标
    public int previousIndex() {
        return cursor-1;
    }

    // 写操作全面禁止！！
    public void remove() {
        throw new UnsupportedOperationException();
    }

  
    public void set(E e) {
        throw new UnsupportedOperationException();
    }

  
    public void add(E e) {
        throw new UnsupportedOperationException();
    }

    // 兼容函数式编程
    @Override
    public void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        Object[] elements = snapshot;
        final int size = elements.length;
        for (int i = cursor; i < size; i++) {
            @SuppressWarnings("unchecked") E e = (E) elements[i];
            action.accept(e);
        }
        cursor = size;
    }
}
```


## 总结

`CopyOnWriteArrayList` 是 Java 并发容器的独特存在，其优势在读操作完全无锁，适用于 **读:写 > 100:1** 的场景，由于是数组实现，在写操作上内存开销大，不适合频繁修改或大数据集，需要在享受 **COW** 的无锁读取红利时，务必警惕其写入代价。理解其底层复制机制，方能发挥最大威力！

并发编程 - CopyOnWriteArrayList 源码分析

并发编程 - 深入了解 AbstractQueuedSynchronizer

并发编程 - ReentrantReadWriteLock 源码解读

在多线程编程中，锁是保证线程安全的核心机制之一。Java除了提供 `synchronized` 关键字外，还通过 java.util.concurrent.locks 包提供了更灵活的锁实现。`ReentrantLock` 是Java并发包中一个重要的锁实现，它提供了比 `synchronized` 更灵活的锁操作。接下来我们深入了解下Java中的可重入锁。



## ReentrantLock介绍

`ReentrantLock` 是Java并发包(java.util.concurrent.locks)中的一个可重入互斥锁实现。与`synchronized` 相比，它提供了以下增强功能：

- 可重入性
    
        同一线程可以多次获得同一把锁，注意避免死锁（例如递归调用场景）

- 公平性

        支持公平锁与非公平锁两种模式
        公平锁：按等待顺序分配锁（构造参数true）
        非公平锁：允许插队（默认模式，吞吐量更高）

- 锁等待可中断

        lockInterruptibly() 方法允许在等待锁时响应中断

- 超时获取锁

        tryLock() 方法可以指定超时时间

- 条件变量支持

        通过 newCondition() 创建多个条件队列

代码示例:

```java
public class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();  // 阻塞获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 必须在finally中释放锁
        }
    }
}
```

:::warning{title="关键点"}
锁释放必须放在finally中，防止异常导致死锁。
:::


## ReentrantLock 锁的实现

基于 AQS 独占模式方式实现的互斥锁，其内部类分为 **公平锁**、**非公平锁**


### NonfairSync：非公平锁实现

非公平锁允许"插队"，当一个线程请求非公平锁时，如果在发出请求的同时该锁的状态变为可用，那么这个线程将跳过队列中所有等待的线程并获得这个锁，如果锁不可用，则与公平锁一样，进入队列排队等待。

对于非公平锁，只要 CAS 设置同步状态成功，则表示当前线程获取了锁
  
**构造函数**

`ReentrantLock` 对象默认构建时就是非公平锁

```java
public ReentrantLock() {
    sync = new NonfairSync();
}
```

非公平锁要比公平锁性能高，减少了锁的上下文切换与调度时间，在没有必要严格执行线程顺序时，非公平锁是最好的选择，所以定义为默认
  
  
### FairSync：公平锁实现

公平的获取锁，也就是等待时间最长的线程最优先获取锁，也可以说锁获取是顺序的，根据 AQS 底层的 FIFO 的双向队列排队

**构造函数**

控制锁是否是公平锁

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

## 实现原理

`ReentrantLock` 底层是基于 AQS 实现的，通过 AQS 维护的 `volatile` 的 `state` 变量来实现锁操作

对于锁的状态控制与可重入性实现，是通过AQS的 `state` 变量表示的，`state` 值为0时，表示锁未被占用，当 `state` 值不为0时，表示锁被占用，数值则是重入的次数。

等待队列是使用 CLH 变体实现线程排队，如果是公平锁模式，则严格按 FIFO 先进先出的顺序获取锁，如果是非公平锁模式，那每次新的线程会插队获取一次锁

:::tip{title="可重入性"}
线程重复n次获取了锁，也就是重入了n次，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放
:::

## 源码分析

### lock 方法源码

`lock` 方法是如何实现让当前线程获取到锁资源（什么效果算是拿到了锁资源）

- 公平锁：调用 `acquire` 方法
- 非公平锁：上来先尝试将 `state` 从0修改为1，如果成功，代表获取锁资源。如果没有成功，调用 `acquire`


**公平&非公平的方法源码**

```java
// 公平锁的sync的lock方法
final void lock() {
    acquire(1);
}

// 非公平锁的sync的lock方法
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}
```

**如果线程修改 state 失败怎么办？**

如果线程没有拿到锁资源，会到AQS的双向链表中排队等待（在期间，线程可能会挂起）

**AQS 的双向链表（队列）是个啥？**

AQS 中的双向链表是基于内部类 Node 在维护，Node中包含 `prev`，`next`，`thread` 属性，并且在 AQS 中还有两个属性，分别是 `head`，`tail`。

**AQS 的核心**

![2ccd93634b77487cafe88d7e8e809def.png](https://blog.liushigong.cn/static/img/5b64eb1310ea6e4aae04875480af64e0.2ccd93634b77487cafe88d7e8e809def.webp)


### acquire 方法源码

`acquire` 是一个业务方法，里面并没有实际的业务处理，都是在调用其他方法

```java
// 核心acquire     arg = 1
public final void acquire(int arg) {
    //1. 调用tryAcquire方法：尝试获取锁资源（非公平、公平），拿到锁资源，返回true，直接结束方法。 没有拿到锁资源，
    //   需要执行&&后面的方法

    //2. 当没有获取锁资源后，会先调用addWaiter：会将没有获取到锁资源的线程封装为Node对象，
    //   并且插入到AQS的队列的末尾，并且作为tail

    //3. 继续调用acquireQueued方法，查看当前排队的Node是否在队列的前面，如果在前面（head的next），尝试获取锁资源
    //   如果没在前面，尝试将线程挂起，阻塞起来！
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
```

### tryAcquire 方法源码

`tryAcquire` 分为公平和非公平两种实现，主要做了两件事：

* 如果state为0，尝试获取锁资源
* 如果state不为0，看一下是不是锁重入操作

#### 非公平锁

```java
// 非公平锁实现！
final boolean nonfairTryAcquire(int acquires) {
    // 拿到当前线程！
    final Thread current = Thread.currentThread();
    // 拿到AQS的state
    int c = getState();
    // 如果state == 0，说明没有线程占用着当前的锁资源
    if (c == 0) {
        // 没人占用锁资源，我直接抢一波（不管有没有线程在排队）
        if (compareAndSetState(0, acquires)) {
            // 将当前占用这个互斥锁的线程属性设置为当前线程
            setExclusiveOwnerThread(current);
            // 返回true，拿锁成功
            return true;
        }
    }
    // 当前state != 0，说明有线程占用着锁资源
    // 判断拿着锁的线程是不是当前线程（锁重入）
    else if (current == getExclusiveOwnerThread()) {
        // 将state再次+1
        int nextc = c + acquires;
        // 锁重入是否超过最大限制
        // 01111111 11111111 11111111 11111111   + 1
        // 10000000 00000000 00000000 00000000
        // 抛出error
        if (nextc < 0) 
            throw new Error("Maximum lock count exceeded");
        // 将值设置给state
        setState(nextc);
        // 返回true，拿锁成功
        return true;
    }
    return false;
}

```

#### 公平锁

```java
// 公平锁实现
protected final boolean tryAcquire(int acquires) {
    // 拿到当前线程！
    final Thread current = Thread.currentThread();
    // 拿到AQS的state
    int c = getState();
    // 阿巴阿巴~~~~
    if (c == 0) {
        // 判断是否有线程在排队，如果有线程排队，返回true，配上前面的!，那会直接不执行返回最外层的false
        if (!hasQueuedPredecessors() &&
            // 如果没有线程排队，直接CAS尝试获取锁资源
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
```

### addWaiter 方法源码

在获取锁资源失败后，需要将当前线程封装为 Node 对象，并且插入到 AQS 队列的末尾

```java
// 将当前线程封装为Node对象，并且插入到AQS队列的末尾
private Node addWaiter(Node mode) {
    // 将当前线程封装为Node对象，mode为null，代表互斥锁
    Node node = new Node(Thread.currentThread(), mode);
    // pred是tail节点
    Node pred = tail;
    // 如果pred不为null，有线程正在排队
    if (pred != null) {
        // 将当前节点的prev，指定tail尾节点
        node.prev = pred;
        // 以CAS的方式，将当前节点变为tail节点
        if (compareAndSetTail(pred, node)) {
            // 之前的tail的next指向当前节点
            pred.next = node;
            return node;
        }
    }
    // 添加的流程为，  自己prev指向、tail指向自己、前节点next指向我
    // 如果上述方式，CAS操作失败，导致加入到AQS末尾失败，如果失败，就基于enq的方式添加到AQS队列
    enq(node);
    return node;
}

// enq，无论怎样都添加进入
private Node enq(final Node node) {
    for (;;) {
        // 拿到tail
        Node t = tail;
        // 如果tail为null，说明当前没有Node在队列中
        if (t == null) { 
            // 创建一个新的Node作为head，并且将tail和head指向一个Node
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 和上述代码一致！
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}
```

### acquireQueued 方法源码

acquireQueued 方法会查看当前排队的 Node 是否是 head 的 next，如果是，尝试获取锁资源，如果不是或者获取锁资源失败那么就尝试将当前 Node 的线程挂起（unsafe.park()）

在挂起线程前，需要确认当前节点的上一个节点的状态必须是小于等于0，

- 如果为1，代表是取消的节点，不能挂起
- 如果为-1，代表挂起当前线程
- 如果为-2，-3，需要将状态改为-1之后，才能挂起当前线程

```java
// acquireQueued方法
// 查看当前排队的Node是否是head的next，
// 如果是，尝试获取锁资源，
// 如果不是或者获取锁资源失败那么就尝试将当前Node的线程挂起（unsafe.park()）
final boolean acquireQueued(final Node node, int arg) {
    // 标识。
    boolean failed = true;
    try {
        // 循环走起
        for (;;) {
            // 拿到上一个节点
            final Node p = node.predecessor();
            if (p == head && // 说明当前节点是head的next
                tryAcquire(arg)) { // 竞争锁资源，成功：true，失败：false
                // 进来说明拿到锁资源成功
                // 将当前节点置位head，thread和prev属性置位null
                setHead(node);
                // 帮助快速GC
                p.next = null; 
                // 设置获取锁资源成功
                failed = false;
                // 不管线程中断。
                return interrupted;
            }
            // 如果不是或者获取锁资源失败,尝试将线程挂起
            // 第一个事情，当前节点的上一个节点的状态正常！
            // 第二个事情，挂起线程
            if (shouldParkAfterFailedAcquire(p, node) &&
				// 通过LockSupport将当前线程挂起
                parkAndCheckInterrupt())
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

// 确保上一个节点状态是正确的
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 拿到上一个节点的状态
    int ws = pred.waitStatus;
    // 如果上一个节点为 -1
    if (ws == Node.SIGNAL)
        // 返回true，挂起线程
        return true;
    // 如果上一个节点是取消状态
    if (ws > 0) {
        // 循环往前找，找到一个状态小于等于0的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 将小于等于0的节点状态该为-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}
```

### unlock 方法源码

释放锁资源：

* 将state-1。
* 如果state减为0了，唤醒在队列中排队的Node。（一定唤醒离head最近的）

释放锁不分公平和非公平，就一个方法。

```java
// 真正释放锁资源的方法
public final boolean release(int arg) {
    // 核心的释放锁资源方法
    if (tryRelease(arg)) {
        // 释放锁资源释放干净了。  （state == 0）
        Node h = head;
        // 如果头节点不为null，并且头节点的状态不为0，唤醒排队的线程
        if (h != null && h.waitStatus != 0)、
            // 唤醒线程
            unparkSuccessor(h);
        return true;
    }
    // 释放锁成功，但是state != 0
    return false;
}
// 核心的释放锁资源方法
protected final boolean tryRelease(int releases) {
    // 获取state - 1
    int c = getState() - releases;
    // 如果释放锁的线程不是占用锁的线程，抛异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 是否成功的将锁资源释放利索 （state == 0）
    boolean free = false;
    if (c == 0) {
        // 锁资源释放干净。
        free = true;
        // 将占用锁资源的属性设置为null
        setExclusiveOwnerThread(null);
    }
    // 将state赋值
    setState(c);
    // 返回true，代表释放干净了
    return free;
}

// 唤醒节点
private void unparkSuccessor(Node node) {
    // 拿到头节点状态
    int ws = node.waitStatus;
    // 如果头节点状态小于0，换为0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 拿到当前节点的next
    Node s = node.next;
    // 如果s == null ，或者s的状态为1
    if (s == null || s.waitStatus > 0) {
        // next节点不需要唤醒，需要唤醒next的next
        s = null;
        // 从尾部往前找，找到状态正常的节点。（小于等于0代表正常状态）
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 经过循环的获取，如果拿到状态正常的节点，并且不为null
    if (s != null)
        // 唤醒线程
        LockSupport.unpark(s.thread);
}
```

**为什么唤醒线程时从尾部往前找，而不是从前往后找？**

因为在 `addWaiter` 操作时，是先将当前 Node 的 prev 指针指向前面的节点，然后是将 tail 赋值给当前Node，最后才是能上一个节点的 next 指针，指向当前 Node。

如果从前往后，通过 next 去找，可能会丢失某个节点，导致这个节点不会被唤醒~ 如果从后往前找，肯定可以找到全部的节点。


## 注意事项

- 锁释放：必须在 finally 中调用 `unlock()`，否则可能导致死锁。

- 避免嵌套：过度嵌套锁会增加死锁风险，尽量降低锁粒度。

- 性能考量：非公平锁在竞争激烈时吞吐量更高，但可能引发 **线程饥饿**。

- 监控工具：使用 `getHoldCount()`、`isHeldByCurrentThread()` 等辅助调试。


:::info{title="什么是线程饥饿？"}
‌线程饥饿（Thread Starvation）‌是指某些线程因长时间无法获得所需的资源或执行机会，导致它们长时间处于等待状态的现象。这种现象通常是由于系统资源分配不公平或不合理造成的‌

**线程饥饿的原因**

‌1）不公平的资源分配策略‌：例如，在优先级调度中，如果高优先级的线程持续占用资源，低优先级的线程可能永远得不到执行机会‌

‌2）锁的非公平实现‌：如果使用非公平锁（如默认的std::mutex），某些线程可能长期被排在队列后面‌

‌3）资源占用时间过长‌：某些线程长时间持有资源，导致其他线程无法获取该资源‌

‌4）死循环或不释放资源‌：如果某个线程获取资源后进入死循环或迟迟不释放资源，其他线程会一直等待‌
:::

## 与 synchronized 对比与选择

| 特性	| ReentrantLock	| synchronized| 
| --- | --- | --- | 
| 锁获取方式	| 显式调用lock()/unlock()	| 隐式（代码块/方法）| 
| 公平性	| 支持公平/非公平模式	| 非公平| 
| 锁中断	| ✅ lockInterruptibly()	| ❌| 
| 超时尝试	| ✅ tryLock(timeout)	| ❌| 
| 条件变量	| ✅ 多Condition支持	| 单一wait()/notify()| 
| 锁释放	| 必须手动unlock()（防死锁）	| 自动释放| 

`ReentrantLock` 通过更灵活的API弥补了 `synchronized` 的局限性，尤其适合复杂并发场景。但其手动管理特性也要求开发者更谨慎地处理锁的获取与释放。


:::warning{title="与 synchronized 进行选择"}
`ReentrantLock` 的危险性比 `synchronized` 要高，如果忘记 `finally` 块中 `unlock` 释放锁，会导致锁一直无法释放，阻塞后续线程

优先考虑 `synchronized`，只有当 `synchronized` 无法满足需求，需要高级功能（如公平性、条件变量）时才考虑使用 `ReentrantLock`，否则，还是应该优先使用 `synchronized`
:::

并发编程 - ReentrantLock 源码解读

baidu-site-verification

本人自己的博客，对工作与学习过程中的总结、一些场景设计的实现方案、遇到过的疑难问题与解决、以及面试总结等。