JDK源码——locks包（一）

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

JDK的Locks包提供了一系列锁和相关同步工具的实现，用于更灵活和精细地控制多线程中的并发访问。

Locks包中的Lock接口是最核心的接口之一，它提供了比synchronized关键字更为丰富的功能，允许以块结构或者非块结构的方式使用锁。Lock接口有六个主要的方法，包括lock()、unlock()、tryLock()等，它们为程序员提供了更多的控制权。ReentrantLock是Lock接口的一个典型实现，它不仅拥有Lock接口的所有功能，还增加了可重入的特性。
在这里插入图片描述

抽象类与接口

AbstractOwnableSynchronizer

这是一个抽象类，提供了锁的拥有者信息。它主要是为了创建具有所有权功能的同步器，例如信号量和事件计数。

类方法信息：
在这里插入图片描述
protected final void setExclusiveOwnerThread(Thread thread)：这是一个受保护的方法，用于设置当前拥有独占访问权限的线程。传入一个线程对象作为参数，如果传入 null，则表示没有线程拥有访问权限。

protected final Thread getExclusiveOwnerThread()：这是一个受保护的方法，用于获取当前拥有独占访问权限的线程。如果没有线程拥有访问权限，返回 null。

AbstractQueuedLongSynchronizer

这是一个为一系列所设计的抽象框架，比如信号量、事件等，其中操作长整型值。它提供了一个基于FIFO的阻塞队列，可以用于构建锁定和相关的同步器。
在这里插入图片描述
类方法信息：
在这里插入图片描述

  1. tryAcquire(long): 尝试获取独占锁，如果成功则返回true，否则返回false。
  2. getFirstQueuedThread(): 获取等待队列中的第一个线程。
  3. addWaiter(Node): 将一个节点添加到等待队列的尾部。
  4. setHead(Node): 设置等待队列的头部为指定的节点。
  5. doAcquireNanos(long, long): 在指定的时间内尝试获取独占锁，如果成功则返回true，否则返回false。
  6. isOnSyncQueue(Node): 判断指定的节点是否在同步队列上。
  7. compareAndSetTail(Node, Node): 原子地比较并设置等待队列的尾部节点。
  8. selfInterrupt(): 中断当前线程。
  9. transferAfterCancelledWait(Node): 在取消等待后尝试将节点转移到同步队列。
  10. isHeldExclusively(): 判断当前线程是否持有独占锁。
  11. getExclusiveQueuedThreads(): 获取所有正在等待独占锁的线程集合。
  12. doAcquireShared(long): 尝试获取共享锁。
  13. acquireShared(long): 以共享模式获取锁。
  14. setState(long): 设置同步状态的值。
  15. apparentlyFirstQueuedIsExclusive(): 判断等待队列中的第一个线程是否应该被视为独占线程。
  16. hasContended(): 判断是否有线程争用锁。
  17. getQueueLength(): 获取等待队列的长度。
  18. fullGetFirstQueuedThread(): 获取等待队列中的第一个线程，包括那些因为调用了park而被阻塞的线程。
  19. doAcquireSharedInterruptibly(long): 以可中断的方式尝试获取共享锁。
  20. hasQueuedThreads(): 判断是否有线程在等待队列中。
  21. tryRelease(long): 尝试释放独占锁，如果成功则返回true，否则返回false。
  22. compareAndSetState(long, long): 原子地比较并设置同步状态的值。
  23. owns(ConditionObject): 判断当前线程是否拥有指定的条件对象的监视器。
  24. compareAndSetNext(Node, Node, Node): 原子地比较并设置节点的下一个节点。
  25. transferForSignal(Node): 将节点从等待队列转移到同步队列，以便唤醒后续等待的线程。
  26. hasWaiters(ConditionObject): 判断是否有线程在指定的条件对象上等待。
  27. acquireQueued(Node, long): 尝试获取队列中的节点所持有的锁。
  28. tryReleaseShared(long): 尝试释放共享锁，如果成功则返回true，否则返回false。
  29. getSharedQueuedThreads(): 获取所有正在等待共享锁的线程集合。
  30. compareAndSetWaitStatus(Node, int, int): 原子地比较并设置节点的等待状态。
  31. getState(): 获取同步状态的值。
  32. acquireInterruptibly(long): 以可中断的方式获取锁。
  33. cancelAcquire(Node?): 取消对指定节点的获取操作。
  34. hasQueuedPredecessors(): 判断当前线程之前是否有其他线程在等待队列中。
  35. shouldParkAfterFailedAcquire(Node, Node): 在获取锁失败后，判断是否应该挂起当前线程。
  36. doAcquireInterruptibly(long): 以可中断的方式尝试获取独占锁。
  37. tryAcquireShared(long): 尝试获取共享锁，返回剩余可用资源的数量。
  38. setHeadAndPropagate(Node, long): 设置等待队列的头部为指定的节点，并传播其状态。
  39. isQueued(Thread): 判断指定的线程是否在等待队列中。
  40. getQueuedThreads(): 获取等待队列中的所有线程。
  41. fullyRelease(Node): 完全释放节点所持有的锁，并返回释放前的状态值。
  42. acquire(long): 获取锁。
  43. toString(): 返回同步器的字符串表示形式。
  44. parkAndCheckInterrupt(): 挂起当前线程，并在唤醒时检查中断状态。
  45. doReleaseShared(): 释放共享锁。
  46. getWaitQueueLength(ConditionObject): 获取指定条件对象的等待队列长度。
  47. tryAcquireSharedNanos(long, long): 在指定的时间内尝试获取共享锁，返回剩余可用资源的数量。
  48. releaseShared(long): 释放共享锁，如果成功则返回true，否则返回false。
  49. release(long): 释放独占锁，如果成功则返回true，否则返回false。
  50. compareAndSetHead(Node): 原子地比较并设置等待队列的头部节点。
  51. unparkSuccessor(Node): 唤醒等待队列中指定节点的后续节点。
  52. tryAcquireNanos(long, long): 在指定的时间内尝试获取独占锁，如果成功则返回true，否则返回false。
  53. findNodeFromTail(Node?): 从等待队列的尾部开始查找指定的节点。
  54. getWaitingThreads(ConditionObject): 获取指定条件对象上等待的所有线程集合。
  55. doAcquireSharedNanos(long, long): 在指定的时间内尝试获取共享锁。
  56. acquireSharedInterruptibly(long): 以可中断的方式获取共享锁。
  57. enq(Node): 将一个节点添加到等待队列的尾部，并返回添加后的节点。

AbstractQueuedSynchronizer

类似于AbstractQueuedLongSynchronizer，但主要面向简单的整数状态。这个类是构造锁和相关同步器的基石，比如信号量和事件。

类方法信息如下：
在这里插入图片描述

  1. tryAcquire(int): 尝试获取独占锁，如果成功则返回true，否则返回false。
  2. enq(Node): 将节点添加到等待队列的尾部，并返回添加后的节点。
  3. acquire(int): 获取独占锁，可能会阻塞直到成功。
  4. hasWaiters(ConditionObject): 判断指定条件对象是否有线程在等待。
  5. releaseShared(int): 释放共享锁，如果成功则返回true，否则返回false。
  6. hasContended(): 判断是否有线程争用锁。
  7. findNodeFromTail(Node?): 从等待队列的尾部开始查找指定的节点。
  8. release(int): 释放独占锁，如果成功则返回true，否则返回false。
  9. fullGetFirstQueuedThread(): 获取等待队列中的第一个线程，包括那些因为调用了park而被阻塞的线程。
  10. compareAndSetHead(Node): 原子地比较并设置等待队列的头部节点。
  11. acquireShared(int): 获取共享锁，可能会阻塞直到成功。
  12. shouldParkAfterFailedAcquire(Node, Node): 在获取锁失败后，判断是否应该挂起当前线程。
  13. apparentlyFirstQueuedIsExclusive(): 判断等待队列中的第一个线程是否拥有独占锁。
  14. doReleaseShared(): 释放共享锁。
  15. tryRelease(int): 尝试释放独占锁，如果成功则返回true，否则返回false。
  16. compareAndSetWaitStatus(Node, int, int): 原子地比较并设置节点的等待状态。
  17. compareAndSetNext(Node, Node, Node): 原子地比较并设置节点的下一个节点。
  18. getWaitQueueLength(ConditionObject): 获取指定条件对象的等待队列长度。
  19. getFirstQueuedThread(): 获取等待队列中的第一个线程。
  20. doAcquireSharedNanos(int, long): 在指定的时间内尝试获取共享锁。
  21. transferForSignal(Node): 唤醒等待队列中指定节点的后续节点。
  22. tryAcquireNanos(int, long): 在指定的时间内尝试获取独占锁。
  23. addWaiter(Node): 将节点添加到等待队列的尾部。
  24. getWaitingThreads(ConditionObject): 获取指定条件对象上等待的所有线程集合。
  25. cancelAcquire(Node?): 取消对指定节点的获取操作。
  26. doAcquireNanos(int, long): 在指定的时间内尝试获取独占锁。
  27. isHeldExclusively(): 判断当前线程是否拥有独占锁。
  28. doAcquireInterruptibly(int): 以可中断的方式获取独占锁。
  29. hasQueuedThreads(): 判断是否有线程在等待队列中。
  30. tryAcquireShared(int): 尝试获取共享锁，返回剩余可用资源的数量。
  31. hasQueuedPredecessors(): 判断当前线程之前是否有其他线程在等待队列中。
  32. isQueued(Thread): 判断指定的线程是否在等待队列中。
  33. setHead(Node): 设置等待队列的头部节点。
  34. tryReleaseShared(int): 尝试释放共享锁，如果成功则返回true，否则返回false。
  35. fullyRelease(Node): 完全释放节点所持有的锁，并返回释放前的状态值。
  36. acquireQueued(Node, int): 获取等待队列中的独占锁，可能会阻塞直到成功。
  37. doAcquireShared(int): 获取共享锁，可能会阻塞直到成功。
  38. getQueueLength(): 获取等待队列的长度。
  39. getExclusiveQueuedThreads(): 获取所有拥有独占锁的线程集合。
  40. doAcquireSharedInterruptibly(int): 以可中断的方式获取共享锁。
  41. acquireInterruptibly(int): 以可中断的方式获取独占锁。
  42. setState(int): 设置同步器的状态值。
  43. setHeadAndPropagate(Node, int): 设置等待队列的头部节点，并传播状态值。
  44. compareAndSetState(int, int): 原子地比较并设置同步器的状态值。
  45. toString(): 返回同步器的字符串表示形式。
  46. transferAfterCancelledWait(Node): 在取消等待后，尝试转移节点到同步队列。
  47. compareAndSetTail(Node, Node): 原子地比较并设置等待队列的尾部节点。
  48. owns(ConditionObject): 判断当前线程是否拥有指定条件的监视器锁。
  49. isOnSyncQueue(Node): 判断节点是否在同步队列上。
  50. acquireSharedInterruptibly(int): 以可中断的方式获取共享锁。
  51. getSharedQueuedThreads(): 获取所有拥有共享锁的线程集合。
  52. getState(): 获取同步器的状态值。
  53. selfInterrupt(): 自我中断当前线程。
  54. parkAndCheckInterrupt(): 挂起当前线程并检查中断状态。
  55. unparkSuccessor(Node): 唤醒等待队列中指定节点的后续节点。
  56. tryAcquireSharedNanos(int, long): 在指定的时间内尝试获取共享锁。
  57. getQueuedThreads(): 获取等待队列中的所有线程集合。

Condition

这是一个接口，它与Lock接口配合使用，使线程能够等待某个特定条件的发生。Condition接口允许更精细的线程同步控制。
在这里插入图片描述

  1. signalAll(): 唤醒所有等待在该Condition上的线程。
  2. awaitNanos(long): 使当前线程等待指定的纳秒数，或者直到其他线程调用signal()或signalAll()。返回值是实际等待的时间（可能小于请求的时间）。
  3. await(): 使当前线程等待，直到其他线程调用signal()或signalAll()。
  4. awaitUninterruptibly(): 使当前线程等待，直到其他线程调用signal()或signalAll()，忽略中断。
  5. await(long, TimeUnit): 使当前线程等待指定的时间量，或者直到其他线程调用signal()或signalAll()。返回值表示是否超时。
  6. signal(): 唤醒一个等待在该Condition上的线程。
  7. awaitUntil(Date): 使当前线程等待直到指定的日期，或者直到其他线程调用signal()或signalAll()。返回值表示是否超时。

Lock

这是一个接口，提供比synchronized关键字更灵活的锁定操作。Lock接口有不同的实现，如ReentrantLock，它允许更复杂的锁定操作，包括尝试获取锁，定时锁等。

类方法如下：
在这里插入图片描述

  1. tryLock(): 尝试获取锁，如果锁可用则立即返回true，否则返回false。
  2. unlock(): 释放锁。
  3. tryLock(long, TimeUnit): 尝试在给定的时间内获取锁，如果在指定时间内成功获取到锁，则返回true，否则返回false。
  4. newCondition(): 创建并返回与此锁关联的条件对象。
  5. lock(): 获取锁，如果锁不可用，则当前线程将被阻塞直到锁被释放。
  6. lockInterruptibly(): 获取锁，如果锁不可用，则当前线程将被阻塞直到锁被释放或者线程被中断。

ReadWriteLock

这是一个接口，管理一对关联的锁，一个用于读，一个用于写。它允许多个线程进行读，但只有一个线程进行写。

类方法如下：
在这里插入图片描述
readLock(): 这个方法返回一个用于读取操作的锁对象。当一个线程调用此方法获取读锁后，它可以访问共享资源，但其他线程仍然可以获取读锁或写锁。这意味着多个线程可以同时进行读取操作，只要没有线程持有写锁。
writeLock(): 这个方法返回一个用于写入操作的锁对象。当一个线程调用此方法获取写锁后，它将独占地访问共享资源，直到释放写锁。在此期间，其他线程不能获取读锁或写锁，以确保数据的一致性和完整性。

吴代庄
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Jdk源码——AQS同步队列解析
等一杯咖啡的博客
12-26 498
前言 本文主要参考自《Java 并发编程的艺术》第五章内容，结合源码对书中内容进行分析补充。 I. Lock接口 在 Lock 接口出现之前，Java程序是靠 synchronized 关键字实现锁功能的，而 Java SE 5 之后，并发包中新增了 Lock 接口（以及相关实现类）用来实现锁功能，它提供了与 synchronized 关键字类似的同步功能，只是在使用时需要显式地获取和释放锁。...
JDK源码研究——ReentrantLock浅析
HinyLover的专栏
09-27 1306
本文简单地介绍一下从JDK1.5开始引入的java.util.concurrent（简称J.U.C）包下的ReentrantLock类。Reentrant的英文含义是“可重入的”，也就是说ReentrantLock表示可重入的锁。这个类是用纯的java语言来实现synchronized关键字的功能，并且补充了synchronized没有实现的部分功能。
JDK源码——locks包（二）
最新发布
吴代庄的博客
08-10 386
这是一个实用工具类，提供基本的线程阻塞原语，如park()和unpark()，用于创建自定义的同步机制。
JDK源码——AQS源码
庄小焱
11-24 943
AQS 就是一个抽象类，继承了AbstractOwnableSynchronizer ，主要用来构建锁和同步器。这个类在 java.util.concurrent.locks 包下面，AQS为构建锁和同步器提供了一些通用功能的实现，因此，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如 ReentrantLock，Semaphore，其他的 ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。
jdk源码分析——Collection 集合
剑八的博客
08-09 374
jdk源码分析——Collection 集合 Collection——java.util.Collection not recommended 不建议使用 - Enumeration                 迭代器，被Iterable取代 - StringTokenizer          字符分割器，建议用split和regex代替 - Vector         ...
Java juc系列4 ——locks包（二）
seethefuture的博客
06-11 550
Java JUC系列目录链接 Java juc系列4 ——locks包（二）locks包简介AQSAQS中的主要成员变量AQS中的主要方法ReentrantLock公平队列同步器非公平队列同步器ReentrantReadWriteLock locks包简介 locks是java.util.concurrent包下的设计线程锁相关的包，今天我们来简单分析一些这个包下面的内容和他们的主要实现原理。 AQS 说到多线程自然会有锁机制，有锁机制自然就有占有锁线程和等待线程，而等待线程就会由我们的AQS（抽象队列同步
JDK1.8源码阅读笔记——Object根父类（一）
weixin_48095246的博客
10-05 362
native关键字 private static native void registerNatives(); static { registerNatives(); } native即JNI，Java Native Interface(Java本地接口,用户和本地C代码进行互操作的API)，也就是说一个native method就是一个java调用非java代码的接口，该方法由非java语言实现，例如C语言。 1、native是用作 java和其他语言进行协作时使用的，也
Java多线程（16）——JUC——locks系列（3）——AQS
波波鱼的博客
09-27 314
目录 0.locks包简介 1.AQS简介 1.1 AQS是什么 1.2AQS框架实现的一些点 1.3 AQS的层次结构 2.AQS原理及源码详解 2.1状态 （1）state实现独占锁的图解 （2）state实现可重入锁的图解 2.2节点Node 2.3同步队列 2.4 加锁函数acquire （1）tryAcquire(int) （2）addWaiter(N...
jdk1.8 源码解读系列（一）——Object类
北北的博客
05-13 1082
/* * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * */ package java.lang; /** * Class {@code ...
C++ - 函数重载
jiaowenjie的专栏
08-06 292
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1061
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Java面试篇（JVM相关专题）
聂可以的博客
08-09 1643
Java面试篇（JVM相关专题）
Spring事务
c1tenj2的博客
08-07 399
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
【SpringBoot】数据验证之分组校验
Jacker
08-05 374
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
反射和注解
supercool7的博客
08-08 209
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java | Leetcode Java题解之第324题摆动排序II
m0_57195758的博客
08-06 325
Java | Leetcode Java题解之第324题摆动排序II
JVM 加载阶段 Class对象加载位置是在 堆中还是方法区？
萧曳丶
08-06 311
Class对象的加载位置：Class对象本身是加载到堆区中的。类的类型信息加载位置：类的类型信息（元数据）是加载到方法区（或元空间）中的。因此，对于问题“jvm 加载阶段 Class加载到堆中还是方法区”，答案是：Class对象加载到堆中，而类的类型信息加载到方法区（或元空间）中。这两个区域在JVM的类加载过程中都扮演着重要的角色，共同支持着Java程序的运行。
dynamic-datasource+Mybatis多数据源使用
tiantiantbtb的博客
08-06 878
严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源。#设置默认的数据源或者数据源组,默认值即为master。#去掉默认使用HikariCP。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吴代庄

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

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

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

打赏作者

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

抵扣说明：

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

余额充值