【Java】ReentrantLock源码分析

最新推荐文章于 2023-02-10 12:00:21 发布
最新推荐文章于 2023-02-10 12:00:21 发布
阅读量308 收藏 2
点赞数
分类专栏： Java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/See_Star/article/details/125528284
版权

文章目录

一、前置知识

1.1 CAS

CAS，Compare And Swap，比较与交换，是一种无锁的算法。在不使用锁的情况下实现多线程之间变量的同步。

CAS操作涉及三个操作数：需要读写的内存值V，进行比较的值A，要写入的新值B。

当V=A时，CAS通过原子方式用新值B更新内存中的旧值V，否则将不会执行操作。一般情况下，”更新“是一个不断重试的操作。

1.2 Unsafe类

在Java中，Unsafe类是CAS的核心类，存在于sun.misc包中，由于Java方法无法直接访问底层系统，需要本地（Native）方法来访问，Unsafe相当于一个后门，其内部方法操作可以像C的指针一样直接操作内存。

CAS，是一条CPU并发原语。它的功能是判断内存某个位置是否位预期值，如果是则更改为新的值，这个过程是原子的。JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。

原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成数据不一致问题。

public final class Unsafe {
	...
	// CAS相关
    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
    public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
    
    // 阻塞相关
    public native void unpark(Object var1);
    public native void park(boolean var1, long var2);
    ...
}

1.2 LockSupport

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语，是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。

LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。

LockSupport和每个使用它的线程都有一个许可（permit）关联，permit相当于1，0开关，默认是0。可以把许可看成是一种(0, 1)信号量（Semaphore），但与Semaphore不同的是，许可的累加上限是1。

调用unpark就加1；调用一次park就会消费一个permit，也就是将1变成0，同时park立刻返回。如果再次调用park会阻塞，因为permit变为零会阻塞在这里，直到permit变为1。permit最大值为1，重复调用也不会累加。

LockSupport.park底层：

public static void park() {
	UNSAFE.park(false, 0L);
}

LockSupport.unpark底层：

public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

📃 代码案例

public class LockSupportDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in！");
            LockSupport.park(); // 阻塞，等待通知放行，它需要许可证
            System.out.println(Thread.currentThread().getName() + "\t" + "---被唤醒！");

        }, "A");
        t1.start();

        Thread t2 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---通知！");
            LockSupport.unpark(t1);
        }, "B");
        t2.start();
    }
}

1.3 AQS

1.3.1 简单介绍

AQS，AbstractQueuedSynchronizer，抽象队列同步器，用来构建锁和同步器的架构。

通过AQS构建的组件有：ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch、CyclicBarrier

AQS核心思想是，如果被请求的资源空闲，则将当前请求资源的线程设置为有效工作线程，并将共享资源设置为锁定状态；如果被请求的共享资源被占用，那么这个线程就要排队等待资源的释放。

通过核心思想我们可以得到两个重要概念：共享资源状态、队列。

  • 共享资源状态：用来判断当前线程是被占用还是空闲。
  • 队列：没有获得资源的线程将放到队列中等待。

在这里插入图片描述
共享资源的状态通过state变量表示，0表示空闲，1表示被占用，通过CAS操作对其状态进行修改。

如果被请求的共享资源被占用。那么将该线程封装到一个Node内，通过CAS操作放到等待队列中的尾部进行排队。

从图中可以看出，CLH队列是一个双向队列，或者说是双向链表，可以通过当前节点获取前后两个节点。

1.3.2 参数介绍

⭐ AQS自身

private volatile int state：0表示资源空闲，线程可以直接获取；1表示资源被占用，线程阻塞等待。

CLH队列：三个大牛的名字组成，为一个双向队列。通过自选等待，state变量判断是否阻塞，从尾部入队，从头部出队。

private transient volatile Node head：头指针

private transient volatile Node tail：尾指针

⭐ 内部类Node

组成：waitStatus等待状态 + 前后指针 + 线程

static final Node SHARED = new Node()：表示线程以共享的模式等待锁

static final Node EXCLUSIVE = null：表示线程以独占的方式等待锁

volatile Node prev：前指针

volatile Node next：后指针

volatile int waitStatus：阻塞线程的等待状态

  • 0，默认值
  • 1，CANCALLED，表示线程获取锁的请求已取消
  • -2，CONDITION，表节点在等待队列中，节点线程等待唤醒
  • -3，PROPAGATE，当前线程处于SHARED情况下，该字段才会使用
  • -1，SIGANAL，表示线程已经准备好了，就等资源释放了

volatile Thread thread：阻塞的线程

在这里插入图片描述

二、源码解读

2.1 分析案例

下面以一段简单的代码为切入点，分析每一步代码是如何运转的。

在该案例中，一共有三个线程和一把锁，它们将依次获取锁，执行任务后释放锁。我们接下来将分析：

  • 如果锁没有被占用，执行lock()后会发生上面？
  • 如果锁被占用，执行lock()后会发生上面？
  • 执行unlock()后会发生上面？
public static void main(String[] args) {
    // ReentrantLock 非公平锁
    Lock lock = new ReentrantLock();
    
    // 线程A
    new Thread(() -> {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
        try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
        lock.unlock();
    }, "A").start();
    
    // 线程B
    new Thread(() -> {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
        try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
        lock.unlock();
    }, "B").start();
    
    // 线程C
    new Thread(() -> {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
        try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
        lock.unlock();
    }, "C").start();
}

2.2 公平锁&非公平锁

公平锁：多个线程按照申请锁的顺序来获取锁，先来先解决。
非公平锁：多线程获取锁的顺序可能不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。

首先来看看ReentrantLock的构造器：

// 创建一个非公平锁的实例
public ReentrantLock() {
    sync = new NonfairSync();
}

// 根据传入参数创建公平锁或非公平锁，true：公平锁，false：非公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

也就是说，我们通过下面这个命令创建的锁是非公平锁：

Lock lock = new ReentrantLock();

2.3 Sync

可以看到非公平锁NonfairSync和公平锁FairSync两个内部类都是继承了Sync内部类。

static final class NonfairSync extends Sync {
	...
}

static final class FairSync extends Sync {
	...
}

而Sync这个抽象内部类则是继承了AQS（AQS就是一个模板）。

abstract static class Sync extends AbstractQueuedSynchronizer {
	...
}

所以说，ReentrantLock的实现原理就是AQS。

2.4 state=0状态下的lock()

第一个线程开始工作【🚩标记0】

// 线程A
new Thread(() -> {
    lock.lock();
    System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
    try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
    lock.unlock();
}, "A").start();

执行第一句lock.lock();

public void lock() {
    sync.lock();
}

最终会定位到NonfairSync中的lock()方法【🚩标记1】

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

首先看compareAndSetState(0, 1)，通过名字也可以看出它的涵义，通过CAS操作将state状态从0变为1。它的实现是通过unsafe中的本地方法来实现的，第一部分已经简单介绍过了。

protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

因为此时资源空闲，所以state=0，因此CAS操作成功，成功把资源状态state设置为1。记住，现在的state=1。

回到【标记1】的代码：

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

if条件成立，执行setExclusiveOwnerThread(Thread.currentThread())，通过名字看出它的含义是：将当前线程设置为拥有锁且正在执行线程，也就是说线程A为这把锁的拥有者。

此时lock.lock()语句执行完毕，回到【标记0】，继续执行下面部分。

System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }

记住，此时state状态为1，线程A拥有这把锁。

2.5 state=1状态下的lock()

第二个线程开始工作【🚩标记2】

// 线程B
new Thread(() -> {
    lock.lock();
    System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
    try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
    lock.unlock();
}, "A").start();

与之前相同，执行第一句lock.lock();

public void lock() {
    sync.lock();
}

与之前相同，最终会定位到NonfairSync中的lock()方法【🚩标记3】

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

与之前相同，执行compareAndSetState(0, 1)，如果state=0，则通过CAS操作将state状态从0变为1，但是state不为0，所以CAS操作失败，if不成立，执行acquire(1)。

下面来看看acquire()方法，传入的参数arg=1【🚩标记4】

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

先看tryAcquire(arg)方法，找到它在AQS中的方法，如果调用AQS中的方法会直接抛出异常，所以子类必须要重写这个方法。如果我们要使用AQS模板自定义一些功能的话，必须要重写这个方法。

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

我们找到它在NonfairSync中的实现。

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

它又调用了Sync中的nonfairTryAcquire(acquires)方法，也就是说【标记4】中的tryAcquire(arg)其实就是nonfairTryAcquire(int acquires)方法。

final boolean nonfairTryAcquire(int acquires) { // 此时 acquires = 1
	// 获取当前线程，当前线程是B线程
    final Thread current = Thread.currentThread();
    // 获取state状态，前面我们反复强调了，state的状态为1，表示被占用（当前被线程A占用）
    int c = getState();
    // state=1，if条件不成立
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 判断当前的线程是不是拥有这个锁的线程，这个地方是判断可重入
    // 拥有锁的线程是A，当前线程是B，所以else if不成立
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    // 最后只能返回false
    return false;
}

经过前面的判断，我们知道了当前state=1，被其他线程占用；同时，该线程不是拥有这个锁的线程，不可重入，将返回false。

【标记4】的代码（重新写一下，这样就不用往上翻了）

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

也就是说【标记4】中的tryAcquire(arg)为false，那么!tryAcquire(arg)为true，接下来就应该将该线程放到队列中等待资源的释放。继续看下面的条件

acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

其中包含两个方法acquireQueued()和addWaiter()

我们先看addWaiter(Node.EXCLUSIVE) 【🚩标记5】

private Node addWaiter(Node mode) {
	// 把当前线程封装成一个Node节点，这是AQS里面的知识点。
	// 传入的mode为Node.EXCLUSIVE，表示独占锁
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    // 获得CLH队列中的为尾节点（未获取共享资源的线程封装为Node节点放到这个CLH队列中等待）
    Node pred = tail;
    // 判断尾节点是否尾null
    // 当前线程封装城的节点是第一个加入到队列中的节点，此时尾节点为null，if条件不成立。
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 尾节点尾null，跳到这里
    enq(node);
    return node;
}

经过分析，此时尾节点pred(也就是tail)为null，调用方法enq(node)【🚩标记6】

private Node enq(final Node node) {
	// for (;;)等价于while(true), 一直循环
    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;
            }
        }
    }
}

执行第一遍enq方法

// 获取尾节点，此时 t = tail = null
Node t = tail; 
// if成立
if (t == null) { // Must initialize
	// 创建一个新的空节点，通过CAS操作把他设置为头结点
	// 这一步会设置成功
    if (compareAndSetHead(new Node()))
    	// 设置成功后，令尾节点等于头结点
        tail = head;
        // 至此，第一遍循环结束
} else {
    node.prev = t;
    if (compareAndSetTail(t, node)) {
        t.next = node;
        return t;
    }
}

【标记6】中说了for (;;)表示一直循环，现在还没有跳出循环，所以下面来看第二遍循环

// 获取尾节点，此时 t = tail = head = 一个空的节点（哨兵节点）
Node t = tail; 
// if条件不成立
if (t == null) { // Must initialize
    if (compareAndSetHead(new Node()))
        tail = head;
// else成立
} else {
	// node节点是传入的参数，也就是封装了线程B的节点
	// 让t节点作为node节点的前置节点。
    node.prev = t;
    // 通过CAS操作将node节点设置为尾节点
    // 该操作能成功
    if (compareAndSetTail(t, node)) {
    	// 由于这是双向链表，node设置成尾节点后，将node设置尾t节点的后置节点
        t.next = node;
        // 最后返回t节点，返回值用不上。
        return t;
    }
}

通过两次循环，我们初始化了这个队列，为队列创建了一个头结点，并将当前节点node设置尾尾节点。也就是说【标记6】enq(node)的作用就是初始化队列，并将当前节点设置为尾节点。

我们回到【标记5】addWaiter(Node.EXCLUSIVE) ，将node节点入队后返回node节点。

private Node addWaiter(Node mode) {
	...
    // 尾节点尾null，跳到这里
    enq(node);
    return node;
}

我们再回到【标记4】的代码，addWaiter(Node.EXCLUSIVE)返回节点node（里面封装了线程B）

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

下面将调用方法acquireQueued(node, arg)【🚩标记7】

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

由于其中包含for (;;)，将执行多次，我们先来看第一次循环【🚩标记8】：

// 获取当前节点的前置节点
// 此时CLH中只有两个节点，当前节点的前置节点就是头结点head
final Node p = node.predecessor();
// p == head成立
// tryAcquire(arg)参考【标记4】，再次尝试获取线程，但还是获取失败了，返回false
// 所以当前if不成立
if (p == head && tryAcquire(arg)) {
    setHead(node);
    p.next = null; // help GC
    failed = false;
    return interrupted;
}
// 上面的if不成立，再看看这个if
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
    interrupted = true;

这个if中包含了两个方法，我们先看看shouldParkAfterFailedAcquire(p, node)【🚩标记9】

p是头结点，node是当前节点（封装线程B的节点）

waitStatus：AQS知识点【详情见1.3.2】，包含五种状态：

  • 0，默认值
  • 1，CANCALLED，表示线程获取锁的请求已取消
  • -2，CONDITION，表节点在等待队列中，节点线程等待唤醒
  • -3，PROPAGATE，当前线程处于SHARED情况下，该字段才会使用
  • -1，SIGANAL，表示线程已经准备好了，就等资源释放了

通过名字看出它的功能是：获取资源失败，应该阻塞线程。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	// pred是头结点，node是当前节点
	// 获取pred头结点的，waitStatus状态，当前头结点为初始化的默认值0
    int ws = pred.waitStatus;
    // 不成立
    if (ws == Node.SIGNAL)
        return true;
    // 不成立
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    // 成立
    } else {
    	// 同CAS操作将，pred节点，也就是头结点的状态从0变为Node.SIGNAL（-1）
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 返回false
    return false;
}

回到【标记8】

// 获取当前节点的前置节点
// 此时CLH中只有两个节点，当前节点的前置节点就是头结点head
final Node p = node.predecessor();
// p == head成立
// tryAcquire(arg)参考【标记4】，再次尝试获取线程，但还是获取失败了，返回false
// 所以当前if不成立
if (p == head && tryAcquire(arg)) {
    setHead(node);
    p.next = null; // help GC
    failed = false;
    return interrupted;
}
// 上面的if不成立，再看看这个if
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
    interrupted = true;

shouldParkAfterFailedAcquire(p, node)为false，if条件不成立。【标记7】中的第一遍循环结束，下面开始第二遍循环。【🚩标记10】

// 获取当前节点的前置节点
// 此时CLH中只有两个节点，当前节点的前置节点还是头结点head
final Node p = node.predecessor();
// p == head成立
// tryAcquire(arg)参考【标记4】，再次尝试获取线程，但还是获取失败了，返回false
// 所以当前if不成立
if (p == head && tryAcquire(arg)) {
    setHead(node);
    p.next = null; // help GC
    failed = false;
    return interrupted;
}
// 上面的if不成立，再看看这个if
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
    interrupted = true;

此时又一次调用shouldParkAfterFailedAcquire(p, node)方法

与【标记9一样】，只不过ws的值发生了改变，在【标记9】中，将ws的值从0设置为Node.SIGNAL（-1），后面的运行的结果将发生改变。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	// pred是头结点，node是当前节点
	// 获取pred头结点的，waitStatus状态，当前头结点为Node.SIGNAL（-1）
    int ws = pred.waitStatus;
    // 成立
    if (ws == Node.SIGNAL)
    	// 返回true
        return true;
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

此时将返回true，回到【标记10】，shouldParkAfterFailedAcquire(p, node)的结果就是true

// 获取当前节点的前置节点
// 此时CLH中只有两个节点，当前节点的前置节点还是头结点head
final Node p = node.predecessor();
// p == head成立
// tryAcquire(arg)参考【标记4】，再次尝试获取线程，但还是获取失败了，返回false
// 所以当前if不成立
if (p == head && tryAcquire(arg)) {
    setHead(node);
    p.next = null; // help GC
    failed = false;
    return interrupted;
}
// 上面的if不成立，再看看这个if
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
    interrupted = true;

下面看看parkAndCheckInterrupt()方法【🚩标记11】

private final boolean parkAndCheckInterrupt() {
	// 阻塞当前线程
    LockSupport.park(this);  // 将一直卡在这里
    return Thread.interrupted();
}

这个地方调用了LockSupport.park(this)方法阻塞当前线程，LockSupport参考【1.2】。

此时线程B完成了入队等待和阻塞的操作，此时将一直阻塞在这里，直到上一个线程释放资源，并通知唤醒线程B。我们记住这个【标记11】，后面通知唤醒线程B后将回到这里。

同理，线程C在执行lock.lock()方法的时候，也会经过上面的过程，线程C封装成的node节点排在最后面作为尾节点，现在队列的状态如下图：

线程C在添加节点的时候不会在执行 【标记5】中enq()方法，因为头结点已经完成了初始化。

在这里插入图片描述

2.6 unlock()

此时回到【标记0】线程A的定义的位置，假设现在线程已经完成了任务，执行lock.unlock()释放锁。

// 线程A
new Thread(() -> {
    lock.lock();
    System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
    try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
    lock.unlock();
}, "A").start();

下面看看lock.unlock()方法在ReentrantLock中的实现：

public void unlock() {
    sync.release(1);
}

调用了sync的release方法，下面看看release()方法【🚩标记12】

public final boolean release(int arg) {
    if (tryRelease(arg)) { // 先执行tryRelease(1)
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

先执行tryRelease(1)方法，找到他在Sync中的实现【🚩标记13】

protected final boolean tryRelease(int releases) {
	// 获取当前线程状态state=1
	// c = 1 - 1 为 0
    int c = getState() - releases;
    // 判断当前线程是不是锁的拥有者
    // A线程拥有这把锁，if不成立
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // if成立
    if (c == 0) {
        free = true;
        // 设置当前拥有这把锁的线程为 null ，表示现在没有线程占用了
        setExclusiveOwnerThread(null);
    }
    // 将state设置为0，表示当前资源空闲（锁没有被占用）
    setState(c);
    // 返回true
    return free;
}

通过tryRelease()方法，将state状态从1变为了0，当前占用的线程从【线程A】变为【null】，此时这把锁已经被释放了。回到【标记12】

public final boolean release(int arg) {
    if (tryRelease(arg)) { // tryRelease返回true，条件成立
        Node h = head;
        // 头结点不为null， 在【标记9】将头结点的waitStatus设置为Node.SIGNAL（-1）
        // 此时条件成立
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h); // 执行方法unparkSuccessor(h)
        return true;
    }
    return false;
}

执行unparkSuccessor(h)，h是头结点。【🚩标记14】

    private void unparkSuccessor(Node node) {
    	// 获得头结点的ws = Node.SIGNAL（-1）
        int ws = node.waitStatus;
        // 条件成立
        if (ws < 0)
        	// 通过CAS的方式将头结点的ws设置为0
            compareAndSetWaitStatus(node, ws, 0);
            
        // 获得头结点的下一个节点，就是线程B封装成的Node节点
        Node s = node.next;
        // 该节点不为null，ws为0
        // 条件不成立
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        
        // s不为null，成立
        if (s != null)
        	// 通过unpark方法唤醒节点对应的线程，也就是线程B
            LockSupport.unpark(s.thread);
    }

通过unparkSuccessor(h)方法，我们成功唤醒了队列中的一个节点封装的线程，也就是线程B。记住，我们在这里唤醒了线程B。

再次回到【标记12】，返回true，不过这个返回结果没什么用。

public final boolean release(int arg) {
    if (tryRelease(arg)) { 
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h); // 该放法执行完毕
        // 返回true
        return true;
    }
    return false;
}

至此，lock.unlock()方法运行完毕。

2.7 阻塞线程被唤醒

回到【标记11】，线程B被阻塞

private final boolean parkAndCheckInterrupt() {
	// 阻塞当前线程
    LockSupport.park(this);  // 将一直卡在这里
    return Thread.interrupted();
}

回到【标记14】，在这里释放了线程B

    private void unparkSuccessor(Node node) {
    	... 
        // s不为null，成立
        if (s != null)
        	// 通过unpark方法唤醒节点对应的线程，也就是线程B
            LockSupport.unpark(s.thread);
    }

所以，此时线程B成功被唤醒，我们回到【标记11】继续运行

private final boolean parkAndCheckInterrupt() {
	// 阻塞当前线程
    LockSupport.park(this); 
    // 线程b没有被中断，所以返回false
    return Thread.interrupted(); 
}

回到【标记7】

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;
            }
            // 因为parkAndCheckInterrupt()返回false，所以这里的if条件不成立
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

我们继续里面的死循环【🚩标记15】

for (;;) {
	// 获得node节点的前置节点，也就是头结点
    final Node p = node.predecessor();
    // p == head成立
    // 我们再去看看tryAcquire(1)方法
    if (p == head && tryAcquire(arg)) {
        setHead(node);
        p.next = null; // help GC
        failed = false;
        return interrupted;
    }
    // 因为parkAndCheckInterrupt()返回false，所以这里的if条件不成立
    if (shouldParkAfterFailedAcquire(p, node) &&
        parkAndCheckInterrupt())
        interrupted = true;
}

下面再看看tryAcquire(arg)方法，这个方法之前已经看过了两次，每一次都返回false。

final boolean nonfairTryAcquire(int acquires) {
	// 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取state状态 = 0
    int c = getState();
    // 条件成立
    if (c == 0) {
    	// 通过CAS操作，将state状态从0变为1，操作一定成功
        if (compareAndSetState(0, acquires)) {
        	// 设置当前线程（线程B）为拥有锁的线程
            setExclusiveOwnerThread(current);
            // 返回true
            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;
}

此时tryAcquire(arg)方法返回true，再回到【标记15】

for (;;) {
	// 获得node节点的前置节点，也就是头结点
    final Node p = node.predecessor();
    // if条件成立
    if (p == head && tryAcquire(arg)) {
    	// 将当前节点设置为头结点
        setHead(node);
        // 将原来的头结点的next指针指向null，垃圾回收的时候会回收掉原来头结点
        p.next = null; // help GC
        failed = false;
        // 返回false
        return interrupted;
    }
    // 因为parkAndCheckInterrupt()返回false，所以这里的if条件不成立
    if (shouldParkAfterFailedAcquire(p, node) &&
        parkAndCheckInterrupt())
        interrupted = true;
}

至此【标记7】处的acquireQueued方法执行完毕，返回false。

再回到【标记4】

public final void acquire(int arg) {
	// 前面讨论过 !tryAcquire(arg) = true
	// 刚刚讨论出acquireQueued() 返回false
	// if条件不成立
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

acquire方法执行完毕，回到【标记3】NonfairSync中的lock()方法，此时lock()运行完毕

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

回到【标记2】，线程获取锁成功，开始工作。

// 线程B
new Thread(() -> {
    lock.lock();
    System.out.println(Thread.currentThread().getName() + "\t" + "开始工作！");
    try {  Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
    lock.unlock();
}, "A").start();

至此，我们分析完了线程空闲状态获取锁、释放锁、阻塞状态获取锁的全过程。

望天边星宿
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java并发系列之ReentrantLock源码分析
08-27
Java并发系列之ReentrantLock源码分析 ReentrantLock是Java 5.0中引入的一种新的加锁机制，它实现了Lock接口，并提供了与synchronized相同的互斥性和内存可见性。ReentrantLock的底层实现是通过AQS来实现多线程同步...
ReentrantLock源码浅析
qq_22610595的博客
11-18 149
1、ReentrantLock可以实现公平锁和非公平锁以及可重入锁的机制，基于AQS和CAS进行加锁处理， 提供了lock和unlock两个api方法进行加锁和释放锁处理。2、以非公平锁为例，lock方法一进去就竞争锁，通过CAS的方式将state变量从0设置为1，如果设置成功，表明竞争锁成功，就将线程变量设置为当前线程，如果失败，就开始排队。3、再次尝试获取锁（tryAcquire），如果继续失败，那么就放弃竞争锁，将自己状态设置为interrupted的。并且开始排队。
Java 源码 - ReentrantLock 源码解析
热门推荐
简单记录一下。
09-30 20万+
不啰嗦，我们直接开始！ 引导语 上两小节我们学习了 AQS，本章我们就要来学习一下第一个 AQS 的实现类：ReentrantLock，看看其底层是如何组合 AQS ，实现了自己的那些功能。 本章的描述思路是先描述清楚 ReentrantLock 的构成组件，然后使用加锁和释放锁的方法把这些组件串起来。 1、类注释 ReentrantLock 中文我们习惯叫做可重入互斥锁，可重入的意思是同一个线程可以对同一个共享资源重复的加锁或释放锁，互斥就是 AQS 中的排它锁的意思，只允许一个线程获得锁。
ReentrantLock源码解析
weixin_48288539的博客
10-27 640
解析了ReentrantLock类的部分重点源码。
Java多线程（二）—— ReentrantLock 源码分析
BASK2311的博客
02-10 169
ReentrantLock 是可重入的互斥锁，虽然具有与 Synchronized 相同的功能，但比 Synchronized 更加灵活。ReentrantLock 底层基于 AQS（AbstractQueuedSynchronizer）实现。
Java锁之ReentrantLock（源码详解）
小道仙的后宫
01-12 977
ReentrantLock 这个Java中重要的锁，我想可能很多人只是听过，并没有使用过，我在看RocketMQ客户端源码的时候发现大量的使用了这个ReentrantLock，从而引起了我的兴趣，下面我们一起从源码的角度来学习ReentrantLock。我们先来看一下ReentrantLock的继承关系。
Java并发之ReentrantLock类源码解析
08-27
ReentrantLock类的源码分析对理解Java并发机制非常重要。本文将对ReentrantLock类的源码进行详细分析，涵盖ReentrantLock的继承关系、构造方法、锁机制、加锁和解锁机制等方面。 ReentrantLock的继承关系 ...
Java并发 结合源码分析AQS原理
08-25
Java并发结合源码分析AQS原理 Java并发编程中，AQS（AbstractQueuedSynchronizer）是一个核心组件，它提供了一个基于FIFO队列和状态变量的基础框架，用于构建锁和其他同步装置。在这篇文章中，我们将深入探讨AQS的...
7、深入理解AQS独占锁之ReentrantLock源码分析(1).pdf
最新发布
02-28
7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set） 实战及其原理.pdf 10、阻塞队列BlockingQueue 实战及其原理分析.pdf
java并发源码分析之实战编程
11-17
"java并发源码分析之实战编程"这个主题深入探讨了Java平台上的并发处理机制，旨在帮助开发者理解并有效地利用这些机制来提高程序性能和可扩展性。在这个专题中，我们将围绕Java并发库、线程管理、锁机制、并发容器...
JUC AQS ReentrantLock源码分析（一）
java_lyvee的专栏
08-09 3万+
Java的内置锁一直都是备受争议的，在JDK 1.6之前，synchronized这个重量级锁其性能一直都是较为低下，虽然在1.6后，进行大量的锁优化策略,但是与Lock相比synchronized还是存在一些缺陷的：虽然synchronized提供了便捷性的隐式获取锁释放锁机制（基于JVM机制），但是它却缺少了获取锁与释放锁的可操作性，可中断、超时获取锁，且它为独占式在高并发场景下性能大打折扣。...
Java ReentrantLock源码分析
Owen的博客
09-27 257
ReentrantLock 是java.util.concurrent.locks下的一个类，主要实现了Synchronized关键字的功能，同时扩展了一些功能，例如 锁投票，定时锁等候和中断锁等候。利用volatile关键字和CAS操作实现。 一、 Lock 接口方法 // 请求锁，直到获取到锁 void lock(); // 获取锁，获取不到就跑异常 void lockInterruptibl...
java并发锁ReentrantLock源码分析二之Condition实现原理
中间件兴趣圈
11-14 5467
1、java.util.concurrent.locks.Condition接口一览 voidawait()throwsInterruptedException; voidawaitUninterruptibly(); longawaitNanos(longnanosTimeout)throwsInterruptedException; booleanawait(lon...
java中lock源代码_Java并发系列之ReentrantLock源码分析
weixin_29587015的博客
02-28 94
在Java5.0之前，协调对共享对象的访问可以使用的机制只有synchronized和volatile。我们知道synchronized关键字实现了内置锁，而volatile关键字保证了多线程的内存可见性。在大多数情况下，这些机制都能很好地完成工作，但却无法实现一些更高级的功能，例如，无法中断一个正在等待获取锁的线程，无法实现限定时间的获取锁机制，无法实现非阻塞结构的加锁规则等。而这些更灵活的加锁...
java锁ReentrantLock的源码分析
u013510360的专栏
06-08 261
java锁ReentrantLock的源码分析简单的函数介绍加锁过程猜测加锁流程源码分析tryAcquireaddWaiterenqacquireQueued解锁流程tryLock,和lockInterruptibly总结 简单的函数介绍 声明锁对象,构造函数默认不传是创建非公平锁,传true是创建一个公平锁 ReentrantLock lock = new ReentrantLock(true); 重入锁,lock和unlock成对出现, lock.lock(); lock.unlock(); 尝试加
Java 锁系列（三）——ReentrantLock源码分析
玖涯博客
10-18 312
一、ReentrantLock 概述 ReentrantLock 是一个可重入的独占锁，是基于 AQS（AbstractQueuedSynchronized，抽象队列式同步器）实现的，它有公平锁和不公平锁两种实现方式。简单查看源码，可以发现 ReentrantLock 其实是一个代理的模式，Reentranlock 的核心是其内部继承自 AbstractQueuedSynchronized 的抽象类 Sync，将 Sync 作为锁的同步基础，其中加锁/解锁等操作其实都是由 Sync 对象完成的，也是通过实例
Java AQS学习-ReentrantLock源代码分析
hotpots--火锅技术栈
10-01 1583
什么是AQS AQS是JUC里并发控制一个很重要的基础，他提供了一个独占和共享访问控制某个状态的工具，JUC里的锁、信号量、门阀都是基于AQS实现的，单独去看AQS的代码很难理解，而且很难理解其设计之精妙，笔者计划依次分析锁(ReentrantLock)、门阀(CountDownLatch)、信号量(Semaphor)、读写锁(ReadWriteLock)来解析AQS的设计细节。
Java并发编程之ReentrantLock源码分析
cherry93925的博客
12-22 233
ReentrantLock介绍 从JDK1.5之前，我们都是使用synchronized关键字来对代码块加锁，在JDK1.5引入了ReentrantLock锁。在JDK1.6之前synchronized关键字性能比ReentrantLock锁要差，JDK1.6之后性能基本是持平，但Reentr...
Java8 ReentrantLock 源码分析
点滴记录
03-07 646
一、ReentrantLock 概述 1.1 ReentrantLock 简介 故名思义，ReentrantLock 意为可重入锁，那么什么是可重入锁呢？可重入意为一个持有锁的线程可以对资源重复加锁而不会阻塞。比如下面这样： public synchronized void f1() { f2(); } private synchronized void ...
Java并发编程深度解析：AQS与ReentrantLock实战
"Java并发编程的关键...通过对AQS源码的分析，我们可以更深入地理解其内部的工作原理，如等待队列的管理、线程的阻塞和唤醒机制，以及状态变更的原子操作。这对于提升并发编程的技能和优化多线程应用的性能至关重要。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

望天边星宿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值