JUC并发编程学习笔记（八）读写锁

读写锁

ReadWriteLock
ReadWriteLock只存在一个实现类那就是ReentrantReadWriteLock，他可以对锁实现更加细粒化的控制
读的时候可以有多个阅读器线程同时参与，写的时候只希望写入线程是独占的

Demo：

1. package org.example.rw;
3. import java.util.HashMap;
4. import java.util.Map;
5. import java.util.concurrent.Semaphore;
6. import java.util.concurrent.TimeUnit;
7. import java.util.concurrent.locks.ReadWriteLock;
8. import java.util.concurrent.locks.ReentrantReadWriteLock;
10. public class ReadWriteLockDemo {
11.     /*
12.     * 读读 - 可以共存 （共享锁）
13.     * 读写 - 不能共存 （独占锁）
14.     * 写写 - 不能共存 （独占锁）
15.     * */
17.     public static void main(String[] args) {
21.         MyCache myCache = new MyCache();
22. //        写入：要求在写入时不能存在插队的情况，以防止写入时资源被抢占
23.         for (int i = 1; i <= 5; i++) {
24.             final int temp = i;
25.             new Thread(()->{
26.                 myCache.put(""+temp,temp);
27.             },String.valueOf(i)).start();
28.         }
29. //        读取：可以插队抢占资源以实现资源的最大化利用
30.         for (int i = 1; i <= 5; i++) {
31.             final int temp = i;
32.             new Thread(()->{
33.                 myCache.get(temp+"");
34.             },String.valueOf(i)).start();
35.         }
36.     }
37. }
38. class MyCache{
39.     private volatile Map<String,Object> cache = new HashMap<>();
40.     ReadWriteLock rwLock = new ReentrantReadWriteLock();
41. //    细粒化控制：写 - 只希望同一时间只有一条线程写入，写入完成后再进入下一位
42.     public void put(String key,Object value){
43.         rwLock.writeLock().lock();
44.         try {
46.             System.out.println(Thread.currentThread().getName()+":"+key+"开始写入");
47.             cache.put(key,value);
48.             System.out.println(Thread.currentThread().getName()+":"+key+"写入完成");
49.         }catch (Exception e){
50.             e.printStackTrace();
51.         }finally {
53.             rwLock.writeLock().unlock();
55.         }
57.     }
58. //    细粒化控制：读 - 所有人都可以读
59.     public Object get(String key){
60.         rwLock.readLock().lock();
62.         Object o = null;
63.         try {
64.             System.out.println(Thread.currentThread().getName()+":"+key+"开始读取");
65.             o = cache.get(key);
67.             System.out.println(Thread.currentThread().getName()+":"+key+"读取完成");
68.         }catch (Exception e){
69.             e.printStackTrace();
70.         }finally {
71.             rwLock.readLock().unlock();
73.         }
75.         return o;
76.     }
77. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！