ReentrantReadWriteLock读写锁

ReentrantReadWriteLock读写锁

乐观锁和悲观锁

乐观锁

乐观锁，就是给需要共享的数据，添加一个版本号version，例如1，每次有线程更新共享数据后，version+1，每次线程进行数据更新时，要比较当前线程持有的数据的版本号，相等则修改，不相等则不修改，支持并发访问。
悲观锁

悲观锁，就是每次只能有一个线程，访问共享的数据，其他线程都阻塞，只有当前线程结束，才会释放锁，其他线程中的一个才能访问，不支持并发访问。
表锁和行锁

表锁

线程涉及到数据库的修改时，其他线程不能修改整个表中的任意行数据，就是表锁，表锁不会出现行锁。
行锁

线程涉及到数据库的修改时，只锁当前的一行，是行锁，可能会出现死锁。
读写锁

读锁是共享锁，写锁是独占锁。都可能出现死锁。
读写锁，一个资源可以被多个读线程访问，或者一个写线程访问，但是不能同时存在读写线程，读写是互斥的，读读是共享的。
案例及代码实现

1. //1.定义资源类
2. class MyCache {
4.     //volatile关键字，共享的数据，在一个线程修改后，被其他线程访问到
5.     private volatile HashMap<String, Object> hashMap = new HashMap<>();
7.     private ReadWriteLock rwLock = new ReentrantReadWriteLock();
9.     //2.定义操作资源类的方法
10.     public Object get(String key) {
11.         rwLock.readLock().lock();//读锁
12.         Object result = null;
13.         try {
14.             System.out.println(Thread.currentThread().getName() + "正在读取值" + key);
16.             TimeUnit.MILLISECONDS.sleep(300);
17.             result = hashMap.get(key);
18.             System.out.println(Thread.currentThread().getName() + "读取值完成" + key);
19.         } catch (InterruptedException e) {
20.             e.printStackTrace();
21.         }finally {
22.             rwLock.readLock().unlock();
23.         }
24.         return result;
25.     }
27.     public void put(String key, Object value) {
28.         rwLock.writeLock().lock();//写锁
29.         try {
30.             System.out.println(Thread.currentThread().getName() + "正在添加值" + key);
31.             TimeUnit.MILLISECONDS.sleep(300);
32.             hashMap.put(key, value);
33.             System.out.println(Thread.currentThread().getName() + "添加值完成" + key);
34.         } catch (InterruptedException e) {
35.             e.printStackTrace();
36.         }finally {
37.             rwLock.writeLock().unlock();
38.         }
40.     }
43. }
45. public class ReadWriteLockDemo {
46.     public static void main(String[] args) {
47.         MyCache cache = new MyCache();
48.         
49.         //创建线程，向缓存中添加值
50.         for (int i = 0; i < 5; i++) {
51.             final int num = i;
52.             new Thread(() -> {
53.                 cache.put(num + "", num);
54.             }, String.valueOf(i)).start();
55.         }
57.         //创建线程，向缓存中获取值
58.         for (int i = 0; i < 5; i++) {
59.             final int num = i;
60.             new Thread(() -> {
61.                 cache.get(num + "");
62.             }, String.valueOf(i)).start();
63.         }
65.     }
66. }

复制代码

读写锁的演变


读写锁的降级


降级案例及代码

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 读写锁降级演示
5. */
6. public class ReadWriteLockDownLevelDemo {
7.     public static void main(String[] args) {
8.         ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
9.         ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();//写锁
10.         ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();//读锁
11.                 //先读后写，获取读锁后，就获取不到写锁，线程阻塞
13.         //1.获取写锁
14.         writeLock.lock();
15.         System.out.println("获取写锁");
17.         //2.获取读锁
18.         readLock.lock();
19.         System.out.println("获取读锁");
21.         //3.释放写锁
22.         writeLock.unlock();
24.         //4.释放读锁
25.         readLock.unlock();
26.     }
27. }

复制代码

小结

• 1.在线程持有读锁的情况下，该线程不能取得写锁，因为获取写锁时，如果写锁对应的读锁被占用，就马上获取失败，不管读锁是否是当前线程持有(原因，此写锁对应的读锁被线程持有，证明有线程正在读取数据，这是为了避免出现幻读现象)。
  
• 2.在线程持有写锁的情况下，该线程可以继续获取读锁。获取读锁时，如果发现写锁被占用，只有写锁没有被当前线程占用的情况下才会获取失败。
  
• 原因，读锁是共享锁，即当某个线程获取读锁时，可能有其他线程同时也在持有读锁；而对于已获取写锁的线程，它一定独占了写锁因此可以继续让其获取读锁，当该线程同时获取了写锁和读锁时，还可以先释放写锁继续持有读锁，这样就称为写锁的降级。
  只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。
  

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