java key锁_Java锁_读写锁

最新推荐文章于 2024-12-01 23:53:54 发布
最新推荐文章于 2024-12-01 23:53:54 发布
阅读量198 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java key锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_29002191/article/details/114536620
本文通过实例代码展示了Java中ReentrantReadWriteLock如何解决并发问题，对比了Synchronized和ReentrantLock，解释了读写锁的概念，强调了读-读能共存、读-写及写-写不能共存的原则。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

独占锁：是指锁一次只能被一个线程持有，ReentrantLock和Synchronized都是独占锁。

共享锁：是指锁可以被多个线程持有。

对于ReentrantReadWriteLock，其读锁是共享锁，写锁是独占锁。

代码示例：如果不设置锁，下面这块代码执行后就会造成一段写操作在完成之前被多个其他操作打断。

1 packagecom.freud.algorithm.other;2

3 importjava.util.HashMap;4 importjava.util.Map;5 importjava.util.concurrent.TimeUnit;6 importjava.util.concurrent.locks.Lock;7 importjava.util.concurrent.locks.ReentrantLock;8

9 /**

10 * 资源类11 */

12 classMyCache {13

14 private volatile Map map = new HashMap<>();15 //private Lock lock = new ReentrantLock();

16 public voidput(String key, Object value) {17

18 System.out.println(Thread.currentThread().getName() + "t 正在写入：" +key);19 //暂停一会儿线程

20 try{21 TimeUnit.MILLISECONDS.sleep(300);22 } catch(InterruptedException e) {23 e.printStackTrace();24 }25 map.put(key, value);26 System.out.println(Thread.currentThread().getName() + "t 写入完成");27 }28

29 public voidget(String key) {30

31 System.out.println(Thread.currentThread().getName() + "t 正在读取：");32 //暂停一会儿线程

33 try{34 TimeUnit.MILLISECONDS.sleep(300);35 } catch(InterruptedException e) {36 e.printStackTrace();37 }38 Object value =map.get(key);39 System.out.println(Thread.currentThread().getName() + "t 读取完成：" +value);40 }41 }42

43 /**

44 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行45 * 但是，如果有一个线程想去写共享资源，就不应该再有其他线程可以对这个资源进行读或者写46 * 小总结：47 * 读-读能共存48 * 读-写不能共存49 * 写-写不能共存50 */

51 public classReadWriteLockDemo {52

53 public static voidmain(String[] args) {54

55 MyCache myCache = newMyCache();56

57 for (int i = 0; i < 5; i++) {58 final int tempInt =i;59 new Thread(() ->{60 myCache.put(tempInt + "", tempInt + "");61 }, String.valueOf(i)).start();62 }63

64 for (int i = 0; i < 5; i++) {65 final int tempInt =i;66 new Thread(() ->{67 myCache.get(tempInt + "");68 }, String.valueOf(i)).start();69 }70 }71 }

打印：

1 "C:Program FilesJavajdk1.8.0_191binjava" "-javaagent:E:JetbrainsIntellijIDEAIntelliJ IDEA 2017.2.6libidea_rt.jar=12592:E:JetbrainsIntellijIDEAIntelliJ IDEA 2017.2.6bin" -Dfile.encoding=UTF-8 -classpath "C:Program FilesJavajdk1.8.0_191jrelibcharsets.jar;C:Program FilesJavajdk1.8.0_191jrelibdeploy.jar;C:Program FilesJavajdk1.8.0_191jrelibextaccess-bridge-64.jar;C:Program FilesJavajdk1.8.0_191jrelibextcldrdata.jar;C:Program FilesJavajdk1.8.0_191jrelibextdnsns.jar;C:Program FilesJavajdk1.8.0_191jrelibextjaccess.jar;C:Program FilesJavajdk1.8.0_191jrelibextjfxrt.jar;C:Program FilesJavajdk1.8.0_191jrelibextlocaledata.jar;C:Program FilesJavajdk1.8.0_191jrelibextnashorn.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunec.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunjce_provider.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunmscapi.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunpkcs11.jar;C:Program FilesJavajdk1.8.0_191jrelibextzipfs.jar;C:Program FilesJavajdk1.8.0_191jrelibjavaws.jar;C:Program FilesJavajdk1.8.0_191jrelibjce.jar;C:Program FilesJavajdk1.8.0_191jrelibjfr.jar;C:Program FilesJavajdk1.8.0_191jrelibjfxswt.jar;C:Program FilesJavajdk1.8.0_191jrelibjsse.jar;C:Program FilesJavajdk1.8.0_191jrelibmanagement-agent.jar;C:Program FilesJavajdk1.8.0_191jrelibplugin.jar;C:Program FilesJavajdk1.8.0_191jrelibresources.jar;C:Program FilesJavajdk1.8.0_191jrelibrt.jar;E:practisealgorithmoutproductionalgorithm"com.freud.algorithm.other.ReadWriteLockDemo2 1 正在写入：1

3 0 正在写入：0

4 2 正在写入：2

5 3 正在写入：3

6 4 正在写入：4

7 0正在读取：8 1正在读取：9 2正在读取：10 3正在读取：11 4正在读取：12 1写入完成13 1 读取完成：1

14 0 读取完成：0

15 0写入完成16 2写入完成17 4写入完成18 3写入完成19 4 读取完成：null

20 3 读取完成：null

21 2 读取完成：2

22

23 Process finished with exit code 0

为了解决这个问题，使得写操作保证原子性不被其他线程打断，加了ReadWriteLock。

1 packagecom.freud.algorithm.other;2

3 importjava.util.HashMap;4 importjava.util.Map;5 importjava.util.concurrent.TimeUnit;6 importjava.util.concurrent.locks.Lock;7 importjava.util.concurrent.locks.ReentrantLock;8 importjava.util.concurrent.locks.ReentrantReadWriteLock;9

10 /**

11 * 资源类12 */

13 classMyCache {14

15 private volatile Map map = new HashMap<>();16 //传统的Lock不足以满足需求17 //private Lock lock = new ReentrantLock();

18 /**

19 * JUC提供了ReentrantReadWriteLock20 */

21 private ReentrantReadWriteLock rwLock = newReentrantReadWriteLock();22

23 /**

24 * put方法25 *@paramkey26 *@paramvalue27 */

28 public voidput(String key, Object value) {29

30 rwLock.writeLock().lock();31 try{32 System.out.println(Thread.currentThread().getName() + "t 正在写入：" +key);33 //暂停一会儿线程

34 try{35 TimeUnit.MILLISECONDS.sleep(300);36 } catch(InterruptedException e) {37 e.printStackTrace();38 }39 map.put(key, value);40 System.out.println(Thread.currentThread().getName() + "t 写入完成");41 } catch(Exception e) {42 e.printStackTrace();43 } finally{44 rwLock.writeLock().unlock();45 }46 }47

48 /**

49 * get方法50 *@paramkey51 */

52 public voidget(String key) {53

54 rwLock.readLock().lock();55 try{56 System.out.println(Thread.currentThread().getName() + "t 正在读取：");57 //暂停一会儿线程

58 try{59 TimeUnit.MILLISECONDS.sleep(300);60 } catch(InterruptedException e) {61 e.printStackTrace();62 }63 Object value =map.get(key);64 System.out.println(Thread.currentThread().getName() + "t 读取完成：" +value);65 } catch(Exception e) {66 e.printStackTrace();67 } finally{68 rwLock.readLock().unlock();69 }70 }71 }72

73 /**

74 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行75 * 但是，如果有一个线程想去写共享资源，就不应该再有其他线程可以对这个资源进行读或者写76 * 小总结：77 * 读-读能共存78 * 读-写不能共存79 * 写-写不能共存80 */

81 public classReadWriteLockDemo {82

83 public static voidmain(String[] args) {84

85 MyCache myCache = newMyCache();86

87 for (int i = 0; i < 5; i++) {88 final int tempInt =i;89 new Thread(() ->{90 myCache.put(tempInt + "", tempInt + "");91 }, String.valueOf(i)).start();92 }93

94 for (int i = 0; i < 5; i++) {95 final int tempInt =i;96 new Thread(() ->{97 myCache.get(tempInt + "");98 }, String.valueOf(i)).start();99 }100 }101 }

打印：

"C:Program FilesJavajdk1.8.0_191binjava" "-javaagent:E:JetbrainsIntellijIDEAIntelliJ IDEA 2017.2.6libidea_rt.jar=18187:E:JetbrainsIntellijIDEAIntelliJ IDEA 2017.2.6bin" -Dfile.encoding=UTF-8 -classpath "C:Program FilesJavajdk1.8.0_191jrelibcharsets.jar;C:Program FilesJavajdk1.8.0_191jrelibdeploy.jar;C:Program FilesJavajdk1.8.0_191jrelibextaccess-bridge-64.jar;C:Program FilesJavajdk1.8.0_191jrelibextcldrdata.jar;C:Program FilesJavajdk1.8.0_191jrelibextdnsns.jar;C:Program FilesJavajdk1.8.0_191jrelibextjaccess.jar;C:Program FilesJavajdk1.8.0_191jrelibextjfxrt.jar;C:Program FilesJavajdk1.8.0_191jrelibextlocaledata.jar;C:Program FilesJavajdk1.8.0_191jrelibextnashorn.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunec.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunjce_provider.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunmscapi.jar;C:Program FilesJavajdk1.8.0_191jrelibextsunpkcs11.jar;C:Program FilesJavajdk1.8.0_191jrelibextzipfs.jar;C:Program FilesJavajdk1.8.0_191jrelibjavaws.jar;C:Program FilesJavajdk1.8.0_191jrelibjce.jar;C:Program FilesJavajdk1.8.0_191jrelibjfr.jar;C:Program FilesJavajdk1.8.0_191jrelibjfxswt.jar;C:Program FilesJavajdk1.8.0_191jrelibjsse.jar;C:Program FilesJavajdk1.8.0_191jrelibmanagement-agent.jar;C:Program FilesJavajdk1.8.0_191jrelibplugin.jar;C:Program FilesJavajdk1.8.0_191jrelibresources.jar;C:Program FilesJavajdk1.8.0_191jrelibrt.jar;E:practisealgorithmoutproductionalgorithm"com.freud.algorithm.other.ReadWriteLockDemo0 正在写入：0

0写入完成1 正在写入：1

1写入完成2 正在写入：2

2写入完成3 正在写入：3

3写入完成4 正在写入：4

4写入完成1正在读取：0正在读取：3正在读取：4正在读取：2正在读取：2 读取完成：2

4 读取完成：4

3 读取完成：3

0 读取完成：0

1 读取完成：1Process finished with exit code0

13561195777
关注
JAVA细粒度 —— KeyLock
皮卡丘_9527的博客
11-04 605
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、JAVA细粒度、互斥KEY锁 —— KeyLock二、实现示例1.实现代码 一、JAVA细粒度、互斥KEY锁 —— KeyLock 前言：java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。本文实现了一个基于KEY（主键）的互斥锁，具有更细的粒度，在缓存或
java的读写锁互斥锁_java线程：互斥锁与读写锁
weixin_42098892的博客
02-21 581
两种互斥锁机制：1、synchronized2、ReentrantLockReentrantLock是jdk5的新特性，采用ReentrantLock可以完全替代替换synchronized传统的锁机制，而且采用ReentrantLock的方式更加面向对象，也更加灵活，网上有很多关于对比两者锁方式的文章，这里就不多口舌了，大家baidu、google一下就水落石出了。在本博客中也写关于这两种锁方式...
JAVA细粒度、互斥KEY锁 —— KeyLock
zhengqiqiqinqin的专栏
11-10 4081
原文地址：http://blog.youkuaiyun.com/icebamboo_moyun/article/details/9391915 java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。本文实现了一个基于KEY（主键）的
java key锁_【转】JAVA细粒度、互斥KEY锁 —— KeyLock
weixin_29955689的博客
02-16 514
java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。本文实现了一个基于KEY(主键)的互斥锁，具有更细的粒度，在缓存或其他基于KEY的场景中有很大的用处。下面将讲解这个锁的设计和实现设想这么一个场景：转账private int[...
java key锁_java中的锁
weixin_27155667的博客
02-16 256
引言在java单线程中，并不会出现资源抢夺的现象，但是在多线程并发中，会出现资源抢夺现象。为了避免这种情况需要上锁分类可重入锁，又名递归锁指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁，也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。使用synchronizedclass Phone{public v...
java名称_简单的基于Java名称的锁？
weixin_30914901的博客
02-20 222
MySQL具有方便的功能：SELECT GET_LOCK("SomeName")这可用于为应用程序创建简单的但非常特定的基于名称的锁。但是，它需要数据库连接。我有很多情况，例如：someMethod() {// do stuff to user A for their data for feature X}简单地同步此方法是没有意义的，因为，例如，如果在此期间同时为用户B调用此方法，则用户B无需等...
USB-Key.rar_USB KEY_java usb_java usb key_usb key开发_usbkey
09-24
Java USB接口提供了与USB设备通信的抽象层，使得开发者无需关心底层硬件细节，可以方便地读写USB Key中的数据。USB Key在Java环境下的开发，主要包括以下步骤： 1. **USB设备枚举**：首先，需要扫描并枚举系统的...
Java 同步锁性能的最佳实践：从理论到实践的完整指南
热门推荐
张彦峰的博客
12-01 9万+
在多线程编程中，锁是保证线程安全的重要手段之一，但如何选择合适的锁并进行优化，一直是我们面临的挑战。本博客探讨Java中同步锁的性能分析与优化之路，从使用同步锁和不使用同步锁的性能对比入手，逐步展开对锁的优化手段和技术原理的解析，帮助读者更好地理解和应用Java中的锁机制。
关于java安全的程序和文档.rar_java security_java 安全_key
09-24
"The-Key-to-Security"项目旨在探讨Java安全机制，并提供了源代码和相关文档，帮助开发者深入理解Java安全模型。以下是这个主题中涵盖的一些关键知识点： 1. **Java安全模型**：Java的安全模型基于沙箱环境，它限制...
Cry-DES.rar_DES JAVA_des_encryption_java 加密解密_java des
09-20
总的来说，Java中的DES加密解密涉及到密钥生成、Cipher对象初始化和加密解密操作，以及文件的读写。虽然DES现在已经不再被视为最安全的加密算法，但在一些旧系统和项目中仍有所使用，理解其原理和实现对于IT从业者来...
java 中的锁的问题
静水流深
05-04 4150
1. synchonrize如何更好地使用? 谈到这个问题, 主要先从这几个方面来入手: 线程的几种状态synchonrize的几种使用方法比较synchonrize和volatile比较synchonrize和juc中的锁比较用了锁就真的没有并发问题了么? 1.1 线程的几种状态 不熟悉线程的生命周期和相互的转换控制, 是无法写好并发代码的.  图简单易懂,
java的keylock_深入理解Java中的锁（三）
weixin_39613712的博客
02-24 370
ReadWriteLock接口读写锁维护一对关联锁，一个只用于读操作，一个只用于写操作。读锁可以由多个线程同时持有，又称共享锁。写锁同一时间只能由一个线程持有，又称互斥锁。同一时间，两把锁不能被不同线程持有。读写锁适合读取操作多于写入操作的场景，改进互斥锁的性能，比如集合的并发安全性改造，缓存组件等。ReentrantReadWriteLock实现原理分析ReentrantReadWriteLoc...
java key锁_java 常用锁
weixin_34220029的博客
02-16 356
公平锁和非公平锁1.公平锁，是指多个线程按照申请的顺序来获取锁，类似排队打饭，先来后到。2.非公平锁，是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发情况下，有可能会造成优先级反转或者饥饿现象。Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁，非公平锁的优点在于吞吐量比公平锁大。对于Synchronize...
java实现key锁 对字符串key加同步锁或超时锁
weixin_40452750的博客
10-16 733
java实现key锁 对字符串key加同步锁或超时锁
Java 根据某个 key 加锁的实现方式
明明如月的技术博客
03-15 3612
日常开发中，有时候需要根据某个 key 加锁，确保多线程情况下，对该 key 的加锁和解锁之间的代码串行执行。 大家可以借助每个 key 对应一个 ReentrantLock ，让同一个 key 的线程使用该 lock 加锁；每个 key 对应一个 Semaphore ，让同一个 key 的线程使用 Semaphore 控制同时执行的线程数。
java key锁_java细粒度锁
weixin_36337823的博客
02-16 979
Java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。下面来提供几个更细的粒度锁：1. 分段锁借鉴concurrentHashMap的分段思想，先生成一定数量的锁，具体使用的时候再根据key来返回对应的lock。这是几个实现里最简...
java key锁_java锁
weixin_35757191的博客
02-16 383
简介:锁一般来说用作资源控制，限制资源访问，防止在并发环境下造成数据错误1.重入锁目的：避免死锁的现象锁作为并发共享数据，保证一致性的工具，在java平台有多种实现synchronized(重量级)和ReentrantLock(轻量级)等等，这些已经写好提供的锁为我们开发提供了便利；重入锁：也叫作递归所，指的是同一线程外层函数获得锁之后，内层递归函数仍然有取该锁的代码，但不受影响；；在java环境...
Java 中通过 key 获取锁的正确方式
明明如月的技术博客
11-15 1701
我们可以使用 ReentrantLock 来实行线程阻塞。我们通过内部类来封装 Lock。该类统计某个 key 上执行的线程数。暴露两个方法，一个是线程数增加，一个是减少线程数。
java 同步锁 key_Java同步锁-synchronized与lock
weixin_35980011的博客
02-16 512
1、synchronized简介synchronized实现同步的基础：java中每个对象都可以作为锁。当线程试图访问同步代码时，必须先获得对象锁，退出或抛出异常时必须释放锁。表现形式为：代码块同步和方法同步。2、synchronized的使用场景方法同步public synchronized void method1(){}复制代码锁住的是该对象的一个实例，当不同线程调用该实例对象中该同步方法，...
java读写锁和互斥锁
最新发布
03-02
### Java 中读写锁与互斥锁的区别及用法 #### 一、概念对比 读写锁（`ReadWriteLock`），也称为『共享-独占锁』，其核心特性在于实现了 **读共享，写独占** 的机制[^1]。这意味着多个线程能够并发地进行读操作而不会相互干扰；然而，在任何时间点上仅允许一个线程持有写权限，并且此时不允许其他任何形式的访问。 相比之下，互斥锁（Mutex Lock 或 `ReentrantLock` 类型）提供了一种更严格的控制方式——即无论是读还是写的请求都必须排队等候当前锁定资源的操作完成之后才能继续执行。换句话说，它并不区分具体的访问模式而是简单粗暴地阻止一切竞争性的尝试直至前序任务结束并释放该对象上的所有权[^4]。 #### 二、适用场景分析 对于那些频繁发生读取动作但更新相对较少的数据结构来说，采用读写锁无疑更加高效合理。因为在这种情况下，大部分时间内都可以让尽可能多的工作单元同时获取到所需的信息而不必担心同步问题所带来的额外开销。例如在一个大型网站的应用程序中维护用户配置文件副本时就非常适合运用此类策略来优化性能表现。 另一方面，如果业务逻辑涉及到大量修改或者存在高度不确定性的交互流程，则可能更适合选用传统的互斥锁方案以确保绝对的安全性和一致性。比如银行转账系统中的账户余额调整过程就需要严格遵循串行化原则从而杜绝潜在的风险隐患。 #### 三、具体实现案例展示 下面给出一段基于 `ReentrantReadWriteLock` 实现简易缓存功能的例子： ```java import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class Cache<K, V> { private final ReadWriteLock lock = new ReentrantReadWriteLock(); public void put(K key, V value){ lock.writeLock().lock(); // 获取写锁 try{ System.out.println(Thread.currentThread().getName()+" write 操作执行"); // 执行实际存储操作... }finally{ lock.writeLock().unlock(); // 解除写锁 } } @SuppressWarnings("unchecked") public V get(K key){ lock.readLock().lock(); // 获取读锁 try{ // 返回查询结果... return (V)"模拟返回值"; }finally{ lock.readLock().unlock(); // 解除读锁 } } } ``` 值得注意的是，上述代码片段展示了如何利用读写锁构建一个多线程安全的缓存组件。其中特别强调了读锁无法创建条件变量的事实，这表明在设计阶段应当充分考虑到这一点以免造成不必要的麻烦[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值