并发编程-锁-ReentrantLock

目录

一、ReentrantLock

1、ReentrantLock和synchronized区别

核心区别       

效率区别

底层实现区别

2、AQS概述

1. AQS 的核心属性

(1) state

(2) head 和 tail

2. Node 内部类

(1) waitStatus

(2) prev 和 next

(3) thread

(4) nextWaiter

3、加锁流程源码

3.1 加锁流程概述

3.2 （重点）三种加锁源码分析

3.2.1 lock方法

1、执行lock方法后，公平锁和非公平锁的实现不一致。

2、acquire方法

3、tryAcquire方法

非公平锁实现

 公平锁实现

4.addWatite方法

5、acquireQueued方法  

3.2.2 tryLock方法

1、tryLock()

2、tryLock(time,unit);

3、cancelAcquire()； 取消节点分析

取消节点整体操作流程

3.2.3 lockInterruptibly方法

4、释放锁流程源码

4.1 释放锁流程概述

释放锁流程：

4.2 释放锁源码分析

5、ConditionObject

---

一、ReentrantLock

1、ReentrantLock和synchronized区别

• 核心区别       

  • ReentrantLock是个类，
  • Synchronized是个关键字
  • 当然都是在JVM层面实现互斥锁的方式

• 效率区别

  • 如果竞争激烈建议使用ReentrantLock，
  • ReentrantLock不存在锁升级的概念。
  • synchronized会在锁竞争激烈的时候触发锁升级，升级到重量级锁后性能就比较差了，且不会有锁降级的策略。

• 底层实现区别

  • ReentrantLock：底层基于AQS实现。
  • Synchronized：底层基于ObjectMonitor实现。

2、AQS概述

简单的介绍这里有： 跳转链接。

AQS就是AbstractQueuedSynchronizer抽象类，AQS其实就是JUC包下的一个基类，JUC下的很多内容都是基于AQS实现了部分功能，比如ReentrantLock，ThreadPoolExecutor，阻塞队列，CountDownLatch，Semaphore，CyclicBarrier等等都是基于AQS实现。

~~~重点！！重点！！重点！！~~

1、AQS提供了一个由volatile修饰，并且有CAS方式修改的int类型的state变量。

2、AQS种维护了一个双向链表，由head，tail，并且每个节点都是Note对象

 --要记住了，后面讲到的源码都是基于这两点。

先看一下Note类长啥样。(它是一个内部类）

package java.util.concurrent.locks; 

static final class Node {

        static final Node SHARED = new Node();  // 共享锁

        static final Node EXCLUSIVE = null;   // 互斥锁（ReentrantLock就是互斥锁）

        static final int CANCELLED =  1;

        static final int SIGNAL    = -1;

        static final int CONDITION = -2;

        static final int PROPAGATE = -3;

        volatile int waitStatus;

        volatile Node prev;

        volatile Node next;

        volatile Thread thread;

        Node nextWaiter;
}

1. AQS 的核心属性

AQS 使用一个 state 属性和一个 双向队列（CLH 队列）来管理线程的同步状态。以下是 AQS 的关键属性：

(1) state

• 类型：volatile int

• 作用：表示同步状态。

  • 对于 ReentrantLock，state 表示锁的持有次数（0 表示未锁定，>0 表示锁定）。

  • 对于 Semaphore，state 表示剩余的许可数量。

  • 对于 CountDownLatch，state 表示剩余的计数。

(2) head 和 tail

• 类型：Node

• 作用：指向 CLH 队列的头部和尾部。

  • CLH 队列是一个双向链表，用于存储等待锁的线程。

  • 每个 Node 代表一个等待线程。

---

2. Node 内部类

Node 是 AQS 中的一个内部类，用于表示 CLH 队列中的节点。以下是 Node 的核心属性：

(1) waitStatus

• 类型：int

• 作用：表示节点的状态，可能的取值包括：

  • CANCELLED (1)：节点已取消（线程已放弃等待）。

  • SIGNAL (-1)：节点的后继节点需要被唤醒。

  • CONDITION (-2)：节点在条件队列中等待。

  • PROPAGATE (-3)：共享模式下，状态需要传播给后继节点。

  • 0：初始状态。

(2) prev 和 next

• 类型：Node

• 作用：指向 CLH 队列中当前节点的前驱和后继节点。

(3) thread

• 类型：Thread

• 作用：表示当前节点关联的线程。

(4) nextWaiter

• 类型：Node

• 作用：

  • 在独占模式下，通常为 null。

  • 在共享模式下，指向下一个等待节点。

  • 在条件队列中，指向条件队列中的下一个节点。

AQS的内部结构属性--这里画个图大致的先在脑子里留个印象。

3、加锁流程源码

3.1 加锁流程概述

非公平锁的流程

1、线程A先执行CAS，将state从0修改为1，线程A就拿到了锁资源。

2、线程B再执行CAS，发现state已经是1了，无法获取到锁资源。

3、线程B去排队，这个时候就会将自己封装成Note对象

4、需要将当前B线程的Node放到双向队列保存，再进行排队

        4.1、但是双向链表中，必须有一个虚拟节点作为头节点（head指向它），并且放入双向队列中

        4.2、将线程B的Note挂在双向头节点后面（B线程是第一个进入的等待线程，所以放在头节点后面），并且tail指向B线程的节点，并且将上一个节点的状态该为-1，再挂起B线程。

---

补充说明：

1、节点状态指的就是waitStatus

2、节点状态 -1 就是上面看到Note类中由个字段（ static final int SIGNAL  =  -1）

3、只有上一个节点的状态为-1才允许将本节点对应的线程挂起。

4、上图中 thread 存放的就是线程对象

3.2 （重点）三种加锁源码分析

3.2.1 lock方法

1、执行lock方法后，公平锁和非公平锁的实现不一致。

 这里把实现的代码copy过来了。代码里面都有注释。

// 非公平锁
final void lock() {
    // 上来就基于CAS的方式，尝试将state从0改为1
    if (compareAndSetState(0, 1))
        // 获取锁资源成功，会将当前线程设置到exclusiveOwnerThread属性，代表是当前线程持有着锁资源
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 执行 acquire方法，尝试获取锁资源
        acquire(1);
}

// 公平锁
final void lock() {
    // 执行 acquire方法，尝试获取锁资源
    acquire(1);
}

2、acquire方法

这个方法 公平锁和非公平锁的实现是一样的。-- 后面有对acquire方法里面每个方法的解析，这里就先看acquire方法是做了什么

public final void acquire(int arg) {
    // tryAcquire:再次查看当前线程是否可以尝试获取锁资源
    if (!tryAcquire(arg) &&
        /*
            没有拿到锁资源
            1、addWaiter(Node.EXCLUSIVE)：当前线程封装为Noede节点，插入到AQS的双向队列中的尾部
            2、acquireQueued()：查看当前线程是否为第一个排队的节点
           · 如果是可以再次尝试获取锁资源，如果长时间拿不到，挂起线程；
           · 如果不是第一个排队的额节点，就尝试挂起线程即可
        */
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 中断线程操作
        selfInterrupt();
}

3、tryAcquire方法

竞争锁资源的逻辑，分为公平锁和非公平锁

非公平锁实现

// 非公平锁实现
final boolean nonfairTryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取了state熟属性
    int c = getState();
    // 判断state当前是否为0,之前持有锁的线程释放了锁资源
    if (c == 0) {
        // 再次抢一波锁资源
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            // 拿锁成功返回true
            return true;
        }
    }
    // 不是0，有线程持有着锁资源
    // 如果当前线程是持有锁的线程，证明是锁重入操作
    else if (current == getExclusiveOwnerThread()) {
        // 将state + 1(这里acquires 传进来的就是1 ，外层写死了)
        int nextc = c + acquires;
        if (nextc < 0) // 说明对重入次数+1后，超过了int正数的取值范围
            // 01111111 11111111 11111111 11111111
            // 10000000 00000000 00000000 00000000
            // 说明重入的次数超过界限了。
            throw new Error("Maximum lock count exceeded");
        // 正常的将计算结果，复制给state
        setState(nextc);
        // 锁重入成功
        return true;
    }
    // 返回false
    return false;
}

 公平锁实现

 // 公平锁实现
   protected final boolean tryAcquire(int acquires) {
       // 获取当前线程
       final Thread current = Thread.currentThread();
       // ....
       int c = getState();
       if (c == 0) {
           // 查看AQS中是否有排队的Node
           // 没人排队抢一手 。有人排队，如果我是第一个，也抢一手
           if (!hasQueuedPredecessors() &&
               // 抢一手~
               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;
   }


 // 查看是否有线程在AQS的双向队列中排队
   // 返回false，代表没人排队
   public final boolean hasQueuedPredecessors() {
       // 头尾节点
       Node t = tail; 
       Node h = head;
       // s为头结点的next节点
       Node s;
       // 如果头尾节点相等，证明没有线程排队，直接去抢占锁资源
       return h != t &&
           // s节点不为null，并且s节点的线程为当前线程（排在第一名的是不是我）
          ((s = h.next) == null || s.thread != Thread.currentThread());
   }

4.addWatite方法

方法：将没有拿到锁资源的线程扔到AQS队列中去排队

// 没有拿到锁资源，过来排队，  mode：代表互斥锁
   private Node addWaiter(Node mode) {
       // 将当前线程封装为Node，
       Node node = new Node(Thread.currentThread(), mode);
       // 拿到尾结点
       Node pred = tail;
       // 如果尾结点不为null
       if (pred != null) {
           // 当前节点的prev指向尾结点
           node.prev = pred;
           // 以CAS的方式，将当前线程设置为tail节点
           if (compareAndSetTail(pred, node)) {
               // 将之前的尾结点的next指向当前节点
               pred.next = node;
               return node;
           }
       }
       // 如果CAS失败，以死循环的方式，保证当前线程的Node一定可以放到AQS队列的末尾
       enq(node);
       return node;
   }


 private Node enq(final Node node) {
       for (;;) {
           // 拿到尾结点
           Node t = tail;
           // 如果尾结点为空，AQS中一个节点都没有，构建一个伪节点，作为head和tail
           if (t == null) { 
               if (compareAndSetHead(new Node()))
                   tail = head;
           } else {
               // 比较熟悉了，以CAS的方式，在AQS中有节点后，插入到AQS队列的末尾
               node.prev = t;
               if (compareAndSetTail(t, node)) {
                   t.next = node;
                   return t;
               }
           }
       }
   }

5、acquireQueued方法  

判断当前线程是否还能再次尝试获取锁资源，如果不能再次获取锁资源，或者又没获取到，尝试将当前线程挂起

// 当前没有拿到锁资源后，并且到AQS排队了之后触发的方法。  中断操作这里不用考虑
final boolean acquireQueued(final Node node, int arg) {
    // 不考虑中断
    // failed：获取锁资源是否失败（这里简单掌握落地，真正触发的，还是tryLock和lockInterruptibly）
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 死循环…………
        for (;;) {
            // 拿到当前节点的前继节点
            final Node p = node.predecessor();
            // 前继节点是否是head，如果是head证明当前线程是第一个进来排队的，则再次执行tryAcquire尝试获取锁资源。
            if (p == head && tryAcquire(arg)) {
                // 获取锁资源成功
                // 设置头结点为当前获取锁资源成功Node，并且取消thread信息
                setHead(node);
                // help GC
                p.next = null; 
                // 获取锁失败标识为false
                failed = false;
                return interrupted;
            }
            // 没拿到锁资源……
            // shouldParkAfterFailedAcquire：基于上一个节点转改来判断当前节点是否能够挂起线程，如果可以返回true，
            // 如果不能，就返回false，继续下次循环
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 这里基于Unsafe类的park方法，将当前线程挂起
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            // 在lock方法中，基本不会执行。
            cancelAcquire(node);
    }
}
// 获取锁资源成功后，先执行setHead
private void setHead(Node node) {
    // 当前节点作为头结点
    head = node;
    // 头结点不需要线程信息
    node.thread = null;
    node.prev = null;
}

// 当前Node没有拿到锁资源，或者没有资格竞争锁资源，看一下能否挂起当前线程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // -1，SIGNAL状态：代表当前节点的后继节点，可以挂起线程，后续我会唤醒我的后继节点
    // 1，CANCELLED状态：代表当前节点以及取消了
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 上一个节点为-1之后，当前节点才可以安心的挂起线程
        return true;
    if (ws > 0) {
        // 如果当前节点的上一个节点是取消状态，我需要往前找到一个状态不为1的Node，作为他的next节点
        // 找到状态不为1的节点后，设置一下next和prev
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 上一个节点的状态不是1或者-1，那就代表节点状态正常，将上一个节点的状态改为-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

3.2.2 tryLock方法

1、tryLock()

无论公平锁还有非公平锁。都会走非公平锁抢占锁资源的操作

// 拿到state的值， 如果是0，直接CAS尝试获取锁资源
// state 不是0，那就看下是不是锁重入操作
// 如果没抢到，或者不是锁重入操作，返回false

public boolean tryLock() {
    // 非公平锁的竞争锁操作
    return sync.nonfairTryAcquire(1);
}


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;
}

2、tryLock(time,unit);

// tryLock(time,unit)执行的方法
public final boolean tryAcquireNanos(int arg, long nanosTimeout)throws InterruptedException {
    // 线程的中断标记位，是不是从false，被改为了true，如果是，直接抛异常
    if (Thread.interrupted())
        throw new InterruptedException();
    // tryAcquire分为公平和非公平锁两种执行方式，如果拿锁成功，直接返回
    return tryAcquire(arg) ||
        // 如果拿锁失败，在这要等待指定时间
        doAcquireNanos(arg, nanosTimeout);
}

private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    // 如果等待时间是0秒，直接告辞，拿锁失败  
    if (nanosTimeout <= 0L)
        return false;
    // 设置结束时间。
    final long deadline = System.nanoTime() + nanosTimeout;
    // 先扔到AQS队列
    final Node node = addWaiter(Node.EXCLUSIVE);
    // 拿锁失败，默认true
    boolean failed = true;
    try {
        for (;;) {
            // 如果在AQS中，当前node是head的next，直接抢锁
            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;
            // shouldParkAfterFailedAcquire：根据上一个节点来确定现在是否可以挂起线程
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 避免剩余时间太少，如果剩余时间少就不用挂起线程
                nanosTimeout > spinForTimeoutThreshold)
                // 如果剩余时间足够，将线程挂起剩余时间
                LockSupport.parkNanos(this, nanosTimeout);
            // 如果线程醒了，查看是中断唤醒的，还是时间到了唤醒的。
            if (Thread.interrupted())
                // 是中断唤醒的！
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

3、cancelAcquire()； 取消节点分析

取消节点整体操作流程

1、线程设置为null

2、从后往前找到有效的节点作为当前节点的prev

3、将waitStatus设置为1，代表节点失效

4、脱离整个AQS队列（分为三种情况分析)

        4.1 当前Node是tail

        4.2 当前节点是head的后继节点

        4.3 不是tail节点，也不是head的后继节点

// 取消在AQS中排队的Node
private void cancelAcquire(Node node) {
    // 如果当前节点为null，直接忽略。
    if (node == null)
        return;
    //1. 线程设置为null
    node.thread = null;

    //2. 往前跳过被取消的节点，找到一个有效节点
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    //3. 拿到了上一个节点之前的next
    Node predNext = pred.next;

    //4. 当前节点状态设置为1，代表节点取消
    node.waitStatus = Node.CANCELLED;

    // 脱离AQS队列的操作
    // 当前Node是尾结点，将tail从当前节点替换为上一个节点
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        // 到这，上面的操作CAS操作失败
        int ws = pred.waitStatus;
        // 不是head的后继节点
        if (pred != head &&
            // 拿到上一个节点的状态，只要上一个节点的状态不是取消状态，就改为-1
            (ws == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) 
            && pred.thread != null) {
            // 上面的判断都是为了避免后面节点无法被唤醒。
            // 前继节点是有效节点，可以唤醒后面的节点
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            // 当前节点是head的后继节点
            unparkSuccessor(node);
        }

        node.next = node; // help GC
    }
}

3.2.3 lockInterruptibly方法

// 这个是lockInterruptibly和tryLock(time,unit)唯一的区别
// lockInterruptibly，拿不到锁资源，就死等，等到锁资源释放后，被唤醒，或者是被中断唤醒
private void doAcquireInterruptibly(int arg) throws InterruptedException {
    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;
            }
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                // 中断唤醒抛异常！
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    // 这个方法可以确认，当前挂起的线程，是被中断唤醒的，还是被正常唤醒的。
    // 中断唤醒，返回true，如果是正常唤醒，返回false
    return Thread.interrupted();
}

4、释放锁流程源码

4.1 释放锁流程概述

 前提场景：

1. 线程A持有当前锁，重入了一次。 state = 2
2. 线程B和线程C获取锁资源失败，在AQS中排队。

释放锁流程：

1. 线程A释放锁资源调用unlock方法，就是执行了tryRelease方法
2. 首先判断是不是线程A持有锁资源，如果不是就抛异常
3. 如果是线程A持有锁资源，对state 减1
4. 减1成功后，会判断state是否为0，如果不为0，方法结束
5. 如果为0，证明当前锁资源释放干净（重入锁，重入了几次就要释放几次锁资源）
6. 查看头节点的状态是否不为0（判断是否为-1，这里暂时不考虑 -2-3），如果为0，代表后面没有挂起的线程
7. 如果不为0 ，代表后面还有等待唤醒的线程，需要唤醒
8. 在唤醒线程是，需要先将当前的-1，改为0，找到有效节点唤醒
9. 找到之后，唤醒线程即可

4.2 释放锁源码分析

 释放锁资源不分为公平锁和非公平锁，都是一个sync对象

public void unlock() {
    // 释放锁资源不分为公平锁和非公平锁，都是一个sync对象
    sync.release(1);
}

// 释放锁的核心流程
public final boolean release(int arg) {
    // 核心释放锁资源的操作之一
    if (tryRelease(arg)) {
        // 如果锁已经释放掉了，走这个逻辑
        Node h = head;
        // h不为null，说明有排队的
        // 如果h的状态不为0（为-1），说明后面有排队的Node，并且线程已经挂起了。
        if (h != null && h.waitStatus != 0)
            // 唤醒排队的线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

// ReentrantLock释放锁资源操作
protected final boolean tryRelease(int releases) {
    // 拿到state - 1（并没有赋值给state）
    int c = getState() - releases;
    // 判断当前持有锁的线程是否是当前线程，如果不是，直接抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // free，代表当前锁资源是否释放干净了。
    boolean free = false;
    if (c == 0) {
        // 如果state - 1后的值为0，代表释放干净了。
        free = true;
        // 将持有锁的线程置位null
        setExclusiveOwnerThread(null);
    }
    // 将c设置给state
    setState(c);
    // 锁资源释放干净返回true，否则返回false
    return free;
}


// 唤醒后面排队的Node
private void unparkSuccessor(Node node) {
    // 拿到头节点状态
    int ws = node.waitStatus;
    if (ws < 0)
        // 先基于CAS，将节点状态从-1，改为0
        compareAndSetWaitStatus(node, ws, 0);
    // 拿到头节点的后续节点。
    Node s = node.next;
    // 如果后续节点为null或者，后续节点的状态为1，代表节点取消了。
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 如果后续节点为null，或者后续节点状态为取消状态，从后往前找到一个有效节点环境
        for (Node t = tail; t != null && t != node; t = t.prev)
            // 从后往前找到状态小于等于0的节点
            // 找到离head最新的有效节点，并赋值给s
            if (t.waitStatus <= 0)
                s = t;
    }
    // 只要找到了这个需要被唤醒的节点，执行unpark唤醒
    if (s != null)
        LockSupport.unpark(s.thread);
}

5、ConditionObject