【JUC】ReentrantLock源码分析

于 2024-05-08 13:04:04 发布
阅读量854 收藏 17
点赞数 21
分类专栏： 程序员 文章标签： 前端 网络 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75232472/article/details/138568070
版权

private Node addWaiter(Node mode) {

//新建一个节点

Node node = new Node(Thread.currentThread(), mode);

//这里先尝试把新节点加到尾节点后面

//如果成功了就返回新节点

//如果没成功再调用enq()方法不断尝试

Node pred = tail;

//如果尾节点不为空

if (pred != null) {

//设置新节点的前置节点为现在的尾节点

node.prev = pred;

// CAS更新尾节点为新节点

if (compareAndSetTail(pred, node)) {

//如果成功，把旧尾节点的下一个节点指向新节点

pred.next = node;

//返回新节点

return node;

}

}

//如果上面尝试入队新节点没成功，调用enq()处理

enq(node);

return node;

}

//AbstractQueuedSynchronizer.enq()

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;

//CAS更新尾节点为新节点

if (compareAndSetTail(t, node)) {

//成功了，则设置旧尾节点的下一个节点为新节点

t.next = node;

//返回旧节点

return t;

}

}

}

}

//AbstractQueuedSynchronizer.acquireQueued()

//调用上面的addWaiter()方法使得新节点已经成功入队了，这个方法是尝试让当前节点来获取锁的

final boolean acquireQueued(final Node node, int arg) {

//失败标记

boolean failed = true;

try {

//中断标记

boolean interrupted = false;

//自旋

for (;😉 {

//当前节点的前一个节点

final Node p = node.predecessor();

//如果当前节点的前一个节点为head节点，则说明轮到自己获取锁了

//调用ReentrantLock.FairSync.tryAcquire()方法再次尝试获取锁

if (p == head && tryAcquire(arg)) {

//尝试获取锁成功

//这里同时只会有一个线程在执行，所以不需要用CAS更新

//把当前节点设置为新的头节点

setHead(node);

//并把上一个节点从链表中删除

p.next = null; // help GC

//标记为未失败

failed = false;

//还是需要获得锁后, 才能返回打断状态

return interrupted;

}

//是否需要阻塞

if (shouldParkAfterFailedAcquire(p, node) &&

//真正阻塞的方法

parkAndCheckInterrupt())

//如果中断了

interrupted = true;

}

} finally {

//如果失败了

if (failed)

//取消获取锁

cancelAcquire(node);

}

}

//AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire()

//第一次调用会把前一个节点的等待状态设置为SIGNAL，并返回false

//第二次调用才会返回true

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

//上一个节点的等待状态

//注意Node的waitStatus字段我们在上面创建Node的时候并没有指定

// 也就是说使用的是默认值0

//这里把各种等待状态再贴出来

// static final int CANCELLED = 1;

// static final int SIGNAL= -1;

// static final int CONDITION = -2;

// static final int PROPAGATE = -3;

int ws = pred.waitStatus;

// 如果等待状态为SIGNAL(等待唤醒)，直接返回true

if (ws == Node.SIGNAL)

return true;

// 如果前一个节点的状态大于0，也就是已取消状态

if (ws > 0) {

// 把前面所有取消状态的节点都从链表中删除

do {

node.prev = pred = pred.prev;

} while (pred.waitStatus > 0);

pred.next = node;

} else {

// 如果前一个节点的状态小于等于0，则把其状态设置为等待唤醒

// 这里可以简单地理解为把初始状态0设置为SIGNAL

// CONDITION是条件锁的时候使用的

// PROPAGATE是共享锁使用的

compareAndSetWaitStatus(pred, ws, Node.SIGNAL);

}

return false;

}

// AbstractQueuedSynchronizer.parkAndCheckInterrupt()

private final boolean parkAndCheckInterrupt() {

//阻塞当前线程

//底层调用的是Unsafe的park()方法

LockSupport.park(this);

//返回是否已中断

return Thread.interrupted();

}

// AbstractQueuedSynchronizer.parkAndCheckInterrupt()

private final boolean parkAndCheckInterrupt() {

//阻塞当前线程

//底层调用的是Unsafe的park()方法

LockSupport.park(this);

//返回是否已中断

return Thread.interrupted();

}

lock()方法的主要流程：

  1. ReentrantLock#lock()

  2. ReentrantLock.FairSync#lock() // 公平模式获取锁

  3. AbstractQueuedSynchronizer#acquire() // AQS的获取锁方法

  4. ReentrantLock.FairSync#tryAcquire() // 尝试获取锁

  5. AbstractQueuedSynchronizer#addWaiter() // 添加到队列

  6. AbstractQueuedSynchronizer#enq() // 入队

  7. >AbstractQueuedSynchronizer#acquireQueued() // 里面有个for()循环，唤醒后再次尝试获取锁

  8. AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire() // 检查是否要阻塞

  9. AbstractQueuedSynchronizer#parkAndCheckInterrupt() // 真正阻塞的地方

公平锁获取锁的主要过程大致如下：

  1. 尝试获取锁，如果获取到了就直接返回了

  2. 尝试获取锁失败，再调用addWaiter()构建新节点并把新节点入队

  3. 然后调用acquireQueued()再次尝试获取锁，如果成功了，直接返回

  4. 如果再次失败，再调用shouldParkAfterFailedAcquire()将节点的等待状态置为等待唤醒（SIGNAL）

  5. 调用parkAndCheckInterrupt()阻塞当前线程

  6. 如果被唤醒了，会继续在acquireQueued()的for()循环再次尝试获取锁，如果成功了就返回

  7. 如果不成功，再次阻塞，重复（3）（4）（5）直到成功获取到锁

独占式同步状态获取流程，也就是acquire(int arg)方法调用流程：

在这里插入图片描述

5.2 非公平锁实现

//ReentrantLock.lock();

public void lock() {

sync.lock();

}

// ReentrantLock.NonfairSync.lock()

final void lock() {

//直接尝试CAS更新状态变量

if (compareAndSetState(0, 1))

//如果更新成功，说明获取到了锁，把当前线程设为独占线程

setExclusiveOwnerThread(Thread.currentThread());

else

acquire(1);

}

//AbstractQueuedSynchronizer.acquire()

public final void acquire(int arg) {

//先尝试加锁

//如果失败了，就排队

if (!tryAcquire(arg) &&

//注意addWaiter()这里传入的节点模式为“独占模式”

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

selfInterrupt();

}

//ReentrantLock.NonfairSync.tryAcquire

protected final boolean tryAcquire(int acquires) {

//调用父类的方法

return nonfairTryAcquire(acquires);

}

// ReentrantLock.Sync.nonfairTryAcquire()

final boolean nonfairTryAcquire(int acquires) {

//获取当前线程

final Thread current = Thread.currentThread();

//获取状态值

int c = getState();

if (c == 0) {

//如果状态变量为0，再次尝试CAS更新状态变量的值

//相对于公平锁模式少了!hasQueuedPredecessors()条件，不会检查AQS队列

if (compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);

return true;

}

}

// 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入

else if (current == getExclusiveOwnerThread()) {

//state++

int nextc = c + acquires;

if (nextc < 0) // overflow

throw new Error(“Maximum lock count exceeded”);

setState(nextc);

return true;

}

return false;

}

相对于公平锁，非公平锁加锁的过程主要有两点不同：

  1. 一开始就尝试CAS更新状态变量state的值，如果成功了就获取到锁了

  2. 在tryAcquire()的时候没有检查是否前面有排队的线程，直接上去获取锁才不管别人有没有排队呢

总的来说，相对于公平锁，非公平锁在一开始就多了两次直接尝试获取锁的过程。

6.lockInterruptibly()方法

可中断地获取锁，和 lock()方法的不同之处在于该方法会响应中断，即在锁的获取中可以中断当前线程

//ReentrantLock.lockInterruptibly()

public void lockInterruptibly() throws InterruptedException {

sync.acquireInterruptibly(1);

}

//AbstractQueuedSynchronizer.acquireInterruptibly(int arg)

public final void acquireInterruptibly(int arg)

throws InterruptedException {

if (Thread.interrupted())

throw new InterruptedException();

//如果没有获得到锁，进入doAcquireInterruptibly方法

if (!tryAcquire(arg))

doAcquireInterruptibly(arg);

}

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())

//在park过程中如果被interrupt会进入这里

//这时候抛出一次，而不会再次进入for循环

throw new InterruptedException();

}

} finally {

if (failed)

cancelAcquire(node);

}

}

7.tryLock()方法

尝试非阻塞的获取锁，调用该方法后立刻返回，如果能够获取则返回true，否则返回false

// ReentrantLock.tryLock()

public boolean tryLock() {

//直接调用Sync的nonfairTryAcquire()方法

return sync.nonfairTryAcquire(1);

}

// ReentrantLock.Sync.nonfairTryAcquire()

final boolean nonfairTryAcquire(int acquires) {

//获取当前线程

final Thread current = Thread.currentThread();

//获取状态值

int c = getState();

if (c == 0) {

//如果状态变量为0，再次尝试CAS更新状态变量的值

//相对于公平锁模式少了!hasQueuedPredecessors()条件

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;

}

tryLock()方法比较简单，直接以非公平的模式去尝试获取一次锁，获取到了或者锁本来就是当前线程占有着就返回true，否则返回false。

8.tryLock(long time, TimeUnit unit)方法

超时的获取锁，当前线程在以下3种情况下会返回：

①当前线程在超时时间内获得了锁

②当前线程在超时时间内被中断

③超时时间结束，返回false

//ReentrantLock.tryLock()

public boolean tryLock(long timeout, TimeUnit unit)

throws InterruptedException {

// 调用AQS中的方法

return sync.tryAcquireNanos(1, unit.toNanos(timeout));

}

// AbstractQueuedSynchronizer.tryAcquireNanos()

public final boolean tryAcquireNanos(int arg, long nanosTimeout)

throws InterruptedException {

//如果线程中断，抛出异常

if (Thread.interrupted())

throw new InterruptedException();

//先尝试获取一次锁

return tryAcquire(arg) ||

doAcquireNanos(arg, nanosTimeout);

}

//AbstractQueuedSynchronizer.doAcquireNanos()

private boolean doAcquireNanos(int arg, long nanosTimeout)

throws InterruptedException {

//如果时间到期，直接返回false

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

//如果时间到期，直接返回false

if (nanosTimeout <= 0L)

return false;

//spinForTimeoutThreshold = 1000L;

//只有到期时间大于1000纳秒才阻塞

//小于等于1000纳秒，直接自旋解决

if (shouldParkAfterFailedAcquire(p, node) &&

nanosTimeout > spinForTimeoutThreshold)

// 阻塞一段时间

LockSupport.parkNanos(this, nanosTimeout);

if (Thread.interrupted())

throw new InterruptedException();

}

} finally {

if (failed)

cancelAcquire(node);

}

}

tryLock(long time, TimeUnit unit)方法在阻塞的时候加上阻塞时间，并且会随时检查是否到期，只要到期了没获取到锁就返回false。

9.unlock()方法

释放锁

public void unlock() {

sync.release(1);

}

public final boolean release(int arg) {

//调用AQS的()方法释放锁

if (tryRelease(arg)) {

Node h = head;

//如果头节点不为空，且等待状态不是0，就唤醒下一个节点

if (h != null && h.waitStatus != 0)

unparkSuccessor(h);

return true;

}

return false;

}

//ReentrantLock.Sync.tryRelease

protected final boolean tryRelease(int releases) {

//state–

int c = getState() - releases;

// 如果当前线程不是占有着锁的线程，抛出异常

if (Thread.currentThread() != getExclusiveOwnerThread())

throw new IllegalMonitorStateException();

boolean free = false;

//如果状态变量的值为0了，说明完全释放了锁

//这也就是为什么重入锁调用了多少次lock()就要调用多少次unlock()的原因

//如果不这样做，会导致锁不会完全释放，别的线程永远无法获取到锁

if (c == 0) {

free = true;

// 清空占有线程

setExclusiveOwnerThread(null);

}

//设置状态变量的值

setState©;

return free;

}

private void unparkSuccessor(Node node) {

//这里node表示头节点

int ws = node.waitStatus;

//如果头节点的等待状态小于0，就把它设置为0

if (ws < 0)

compareAndSetWaitStatus(node, ws, 0);

//头节点的下一个节点

Node s = node.next;

//如果下一个节点为空，或者其等待状态大于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;

}

//如果下一个节点不为空，则唤醒它

if (s != null)

LockSupport.unpark(s.thread);

}

释放锁的过程大致为：

  1. 将state的值减1

  2. 如果state减到了0，说明已经完全释放锁了，唤醒下一个等待着的节点

10.ConditionObject的主要属性

public class ConditionObject implements Condition, java.io.Serializable {

/**

  • First node of condition queue.

*/

private transient Node firstWaiter;

/**

  • Last node of condition queue.

*/

private transient Node lastWaiter;

}

可以看到条件锁中也维护了一个队列，为了和AQS的队列区分，我这里称为条件队列，firstWaiter是队列的头节点，lastWaiter是队列的尾节点。

11.lock.newCondition()方法

// ReentrantLock.newCondition()

public Condition newCondition() {

return sync.newCondition();

}

// ReentrantLock.Sync.newCondition()

final ConditionObject newCondition() {

return new ConditionObject();

}

// AbstractQueuedSynchronizer.ConditionObject.ConditionObject()

public ConditionObject() {

}

新建一个条件锁最后就是调用的AQS中的ConditionObject类来实例化条件锁。

12.condition.await()方法

// AbstractQueuedSynchronizer.ConditionObject.await()

public final void await() throws InterruptedException {

// 如果线程中断了，抛出异常

if (Thread.interrupted())

throw new InterruptedException();

//添加节点到Condition的队列中，并返回该节点

Node node = addConditionWaiter();

//完全释放当前线程获取的锁,因为锁是可重入的，所以这里要把获取的锁全部释放

int savedState = fullyRelease(node);

int interruptMode = 0;

//如果该节点还没有转移至 AQS 队列, 阻塞

while (!isOnSyncQueue(node)) {

//阻塞当前线程

LockSupport.park(this);

//如果被打断, 退出等待队列

if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)

break;

}

//退出等待队列后, 还需要获得 AQS 队列的锁

if (acquireQueued(node, savedState) && interruptMode != THROW_IE)

interruptMode = REINTERRUPT;

//清除取消的节点

if (node.nextWaiter != null) // clean up if cancelled

unlinkCancelledWaiters();

//线程中断相关

if (interruptMode != 0)

reportInterruptAfterWait(interruptMode);

}

// AbstractQueuedSynchronizer.ConditionObject.addConditionWaiter

private Node addConditionWaiter() {

Node t = lastWaiter;

// 如果条件队列的尾节点已取消，从头节点开始清除所有已取消的节点

if (t != null && t.waitStatus != Node.CONDITION) {

unlinkCancelledWaiters();

//重新获取尾节点

t = lastWaiter;

}

//新建一个节点，它的等待状态是CONDITION

Node node = new Node(Thread.currentThread(), Node.CONDITION);

//如果尾节点为空，则把新节点赋值给头节点（相当于初始化队列）

if (t == null)

firstWaiter = node;

//否则把新节点赋值给尾节点的nextWaiter指针

else

t.nextWaiter = node;

//尾节点指向新节点

lastWaiter = node;

//返回新节点

return node;

}

//AbstractQueuedSynchronizer.fullyRelease

final int fullyRelease(Node node) {

boolean failed = true;

try {

//获取状态变量的值，重复获取锁，这个值会一直累加

//这个值也代表着获取锁的次数

int savedState = getState();

//一次性释放所有获得的锁

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
//新建一个节点，它的等待状态是CONDITION

Node node = new Node(Thread.currentThread(), Node.CONDITION);

//如果尾节点为空，则把新节点赋值给头节点（相当于初始化队列）

if (t == null)

firstWaiter = node;

//否则把新节点赋值给尾节点的nextWaiter指针

else

t.nextWaiter = node;

//尾节点指向新节点

lastWaiter = node;

//返回新节点

return node;

}

//AbstractQueuedSynchronizer.fullyRelease

final int fullyRelease(Node node) {

boolean failed = true;

try {

//获取状态变量的值，重复获取锁，这个值会一直累加

//这个值也代表着获取锁的次数

int savedState = getState();

//一次性释放所有获得的锁

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-PYiuwJqM-1715144625298)]

[外链图片转存中…(img-0R28C86W-1715144625300)]

[外链图片转存中…(img-UOqNJhtM-1715144625301)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

一条小尾鱼
关注
  • 21
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ReentrantLock源码解析
weixin_48288539的博客
10-27 650
解析了ReentrantLock类的部分重点源码。
7、深入理解AQS独占锁之ReentrantLock源码分析(1).pdf
最新发布
02-28
7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set） 实战及其原理.pdf 10、阻塞队列BlockingQueue 实战及其原理分析.pdf
并发编程基础ReentrantLock源码分析
北洋的博客
02-16 2482
//Note1:（双向链表。初始的时候head和tail都指向Null，之后添加新节点的时候会创建一个空Node，head和tail都指向这个空Node代表初始化完成。尾插法入队通过移动尾结点tail往前移动,出队通过移动head节点head节点往前移动。当Head节点和tail指向同一个Node时代表没有阻塞队列中没有等待的线程） //之后唤醒的时候也会通过tail尾结点一直像后遍历拿到真正处于等待状态的Node线程，然后通过LockSupport提供的Unpark指定唤醒Node线程； // 阻塞的时候
ReentrantLock源码分析
weixin_45271492的博客
12-05 268
在分析ReentrantLock前，还是需要直到AQS是什么的。AbstractQueuedSynchronizer队列同步器，简称AQS，是用来构建锁或者其他同步组件的基础框架，常用的ReentrantLock、ConuntDownLatch、Semaphore等JUC包下的组件都是基于AQS来实现的。 AQS使用了一个int的成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。AQS定义了两种资源共享方式，独占和共享。本文说是分析ReentrantLock，实际上是借着它来分析AQ
ReentrantLock的源码分析
雅俗共赏的博客
01-19 397
ReentrantLock的公平锁和非公平锁的具体实现及其区别
Renntrantlock原理（源码解析）
qq_40223516的博客
04-24 1404
Renntrantlock原理（源码） 文章目录前言一、ReentrankLockAQS部分源码二、Reentrantlock原理3.ReentrantLock源码实现3.1核心变量和构造器2.公平与非公平锁实现原理总结 前言 记录第一次写博客，在面试中，经常发现会问Synchronized与ReentrantLock的区别，我们知道Synchronized底层是JVM实现的，在字节码中修饰在方法层面的同步关键字，会多一个 ACC_SYNCHRONIZED的判别位，修饰在代码块层面的同步块会多一个 mon
并发编程、juc工具包源码分析笔记
11-03
Java 并发库（Java Util Concurrency, JUC）是 Java 平台中用于处理并发问题的核心工具包，提供了丰富的类和接口来简化并发编程。 在计算机系统中，进程是操作系统资源分配的基本单位，它拥有独立的内存空间，而...
juc源码视频教程最全
05-22
本教程将深入探讨JUC源码，旨在帮助你全面理解其背后的实现原理。 在Java中，JUC（java.util.concurrent）包包含了多种并发控制和同步组件，如线程池、锁、原子变量、并发容器等。这些组件设计精巧，性能优秀，能够...
juc-learn:juc相关源码的分析以及使用介绍
03-23
本项目"juc-learn"专注于JUC相关源码的分析和使用介绍，旨在帮助开发者深入理解并熟练运用这些并发工具。 1. **并发基础** 在Java中，多线程是并发编程的基础。通过创建Thread对象或实现Runnable接口，我们可以...
Java并发包源码分析(JDK1.8)
06-13
Java并发包源码分析(JDK1.8)：囊括了java.util.concurrent包中大部分类的源码分析，其中涉及automic包，locks包(AbstractQueuedSynchronizer、ReentrantLock、ReentrantReadWriteLock、LockSupport等)，queue...
ReentrantLock源码浅析
qq_22610595的博客
11-18 154
1、ReentrantLock可以实现公平锁和非公平锁以及可重入锁的机制，基于AQS和CAS进行加锁处理， 提供了lock和unlock两个api方法进行加锁和释放锁处理。2、以非公平锁为例，lock方法一进去就竞争锁，通过CAS的方式将state变量从0设置为1，如果设置成功，表明竞争锁成功，就将线程变量设置为当前线程，如果失败，就开始排队。3、再次尝试获取锁（tryAcquire），如果继续失败，那么就放弃竞争锁，将自己状态设置为interrupted的。并且开始排队。
并发编程源码解析（一）ReentrantLock源码解析（超详细）
qq_33781946的博客
11-11 547
是中的一个互斥锁，它允许线程重入锁定的代码段，而不会产生死锁。它实现了Lock 接口，内部继承了(AbstractQueuedSynchronizer) 并提供了比更多的灵活性和功能，例如可中断锁、超时锁、公平锁和多条件变量。的主要作用是实现线程间的同步和互斥访问共享资源，保证数据的一致性和完整性。在锁竞争的比较激烈的情况，优先推荐使用，具体原因以后解析的时候再来详细说明。
ReenTrantLock源码解析
不争朝夕
11-28 708
可重入锁在实现上基于AQS框架，内部维护线程的state以及队列（CLH）的waitStatus,大量采用非阻塞算法，在中低量的并发上效率是非常高的。 下面分多种情况分析源码，这里只分析非公平锁。 1.简单应用，不使用条件队列 final ReentrantLock lock=new ReentrantLock(); for (int i = 0; i &lt;2; i...
ReentrantLock源码分析全
神韵
09-08 546
目录 图片分析过程 源码分析 一、t1线程拿锁源码分析过程 二、t2线程拿锁失败进入队列阻塞源码分析过程 三、t3线程拿锁失败进入队列阻塞源码分析过程 四、t1释放锁源码分析过程 五、t2线程被唤醒后拿锁源码分析过程 六、t2线程释放锁源码分析过程 七、t3线程被唤醒后拿到锁源码分析过程 八、t3线程释放锁源码分析过程 下面的源码分析将围绕三个线程的使用来介绍源码，先图...
"深入学习并发编程：JUC工具包源码分析与Java线程基础
JUC（Java.util.concurrent）工具包就是Java提供的一个用于并发编程的工具包，它提供了许多并发编程中常用的工具类和高效的并发数据结构。 在学习并发编程之前，我们需要先了解并发编程的基础知识。首先，进程和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值