devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JUC并发编程第十三章——读写锁、邮戳锁_juc的面试题 锁升级和锁降级

作者：Guff_9hys | 2024-08-10 01:46:54

赞

踩

juc的面试题 锁升级和锁降级

本章路线总纲

无锁——>独占锁——>读写锁——>邮戳锁

1 关于锁的面试题

  • 你知道Java里面有那些锁
  • 你说说你用过的锁，锁饥饿问题是什么？
  • 有没有比读写锁更快的锁
  • StampedLock知道吗？（邮戳锁/票据锁）
  • ReentrantReadWriteLock有锁降级机制，你知道吗？

2 简单聊聊ReentrantReadWriteLock

类图：

读写锁的演变情况：

2.1 是什么？

读写锁说明

  • 一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程

演变

  • 无锁无序->加锁->读写锁->邮戳锁

读写锁意义和特点

  • 读写锁只允许读读共存，而读写和写写依然是互斥的，恰好大多实际场景是”读/读“线程间不存在互斥关系，只有”读/写“线程或者”写/写“线程间的操作是需要互斥的，因此引入了 ReentrantReadWriteLock
  • 一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但是不能同时存在写锁和读锁，也即资源可以被多个读操作访问，或一个写操作访问，但两者不能同时进行。
  • 只有在读多写少情景之下，读写锁才具有较高的性能体现。

2.2 特点

可重入、读写兼顾

结论：一体两面，读写互斥，读读共享，读没有完成的时候其他线程写锁无法获得

ReentrantReadWriteLock的缺点：

1. 锁饥饿问题：

  • ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，因此当前有可能会一直存在读锁，而无法获得写锁。

2. 锁降级：

  • 将写锁降级为读锁------>遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级为读锁
  • 如果一个线程持有了写锁，在没有释放写锁的情况下，它还可以继续获得读锁。这就是写锁的降级，降级成为了读锁。
  • 如果释放了写锁，那么就完全转换为读锁
  • 如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略

2.3 读写锁案例

  • 使用读写锁之前，使用synchronized的情况
  1. public class ReentrantReadWriteLockDemo {
  2.     public static void main(String[] args) {
  3.         MyCache cache = new MyCache();
  4.  
  5.         //开启10个线程，写入数据
  6.         for (int i = 1; i <= 10; i++) {
  7.             int finalI = i;
  8.             new Thread(() -> {
  9.                 cache.write(finalI + "", finalI + "");
  10.             }, String.valueOf(i)).start();
  11.         }
  12.  
  13.         //开启10个线程，读取数据
  14.         for (int i = 1; i <= 10; i++) {
  15.             int finalI = i;
  16.             new Thread(() -> {
  17.                 cache.read(finalI + "");
  18.             }, String.valueOf(i)).start();
  19.         }
  20.     }
  21. }
  22.  
  23. //模拟一个缓存资源类，有读写两种功能
  24. class MyCache {
  25.  
  26.     HashMap<String, String> map = new HashMap<>();
  27.  
  28.      ReentrantLock lock = new ReentrantLock();
  29.  
  30.     //读写都加锁
  31.     public void write(String key, String value) {
  32.         lock.lock();
  33.         try {
  34.             System.out.println(Thread.currentThread().getName() + "线程开始写入数据...");
  35.             //延迟500ms模拟业务耗时，同时可以看出读写不能共同执行 (因为运行结果是先打印一个线程写入，再打印对应线程写入完成)
  36.             TimeUnit.MILLISECONDS.sleep(500);
  37.             map.put(key, value);
  38.             System.out.println(Thread.currentThread().getName() + "线程完成写入数据!");
  39.         } catch (InterruptedException e) {
  40.             e.printStackTrace();
  41.         }finally {
  42.             lock.unlock();
  43.         }
  44.     }
  45.  
  46.     public void read(String key) {
  47.         lock.lock();
  48.         try {
  49.             System.out.println(Thread.currentThread().getName() + "线程开始读取数据...");
  50.             String val = map.get(key);
  51.             TimeUnit.MILLISECONDS.sleep(200);
  52.             System.out.println(Thread.currentThread().getName() + "线程读取到的数据是：\t" + val);
  53.         } catch (InterruptedException e) {
  54.             e.printStackTrace();
  55.         }finally {
  56.             lock.unlock();
  57.         }
  58.     }
  59. }
  60. 运行结果：
  61. 1线程开始写入数据...
  62. 1线程完成写入数据!
  63. 2线程开始写入数据...
  64. 2线程完成写入数据!
  65. 3线程开始写入数据...
  66. 3线程完成写入数据!
  67. 4线程开始写入数据...
  68. 4线程完成写入数据!
  69. 5线程开始写入数据...
  70. 5线程完成写入数据!
  71. 6线程开始写入数据...
  72. 6线程完成写入数据!
  73. 7线程开始写入数据...
  74. 7线程完成写入数据!
  75. 9线程开始写入数据...
  76. 9线程完成写入数据!
  77. 8线程开始写入数据...
  78. 8线程完成写入数据!
  79. 10线程开始写入数据...
  80. 10线程完成写入数据!
  81. 1线程开始读取数据...
  82. 1线程读取到的数据是：	1
  83. 2线程开始读取数据...
  84. 2线程读取到的数据是：	2
  85. 3线程开始读取数据...
  86. 3线程读取到的数据是：	3
  87. 4线程开始读取数据...
  88. 4线程读取到的数据是：	4
  89. 5线程开始读取数据...
  90. 5线程读取到的数据是：	5
  91. 6线程开始读取数据...
  92. 6线程读取到的数据是：	6
  93. 7线程开始读取数据...
  94. 7线程读取到的数据是：	7
  95. 8线程开始读取数据...
  96. 8线程读取到的数据是：	8
  97. 9线程开始读取数据...
  98. 9线程读取到的数据是：	9
  99. 10线程开始读取数据...
  100. 10线程读取到的数据是：	10

说明：可以看出，开始写入/读取和完成写入/读取，都是成对出现的。这说明这写入/读取期间，其他线程不能执行写入/读取。读写/读读/写写都互斥了。

问题：我们希望的情况应该是，读写/写写都互斥，但读读可以并发读取。从而引出了读写锁（对写独占，对读共享）

  • 使用读写锁
  1. public class ReentrantReadWriteLockDemo {
  2.     public static void main(String[] args) {
  3.         MyCache cache = new MyCache();
  4.  
  5.         //开启10个线程，写入数据
  6.         for (int i = 1; i <= 10; i++) {
  7.             int finalI = i;
  8.             new Thread(() -> {
  9.                 cache.write(finalI + "", finalI + "");
  10.             }, String.valueOf(i)).start();
  11.         }
  12.  
  13.         //开启10个线程，读取数据
  14.         for (int i = 1; i <= 10; i++) {
  15.             int finalI = i;
  16.             new Thread(() -> {
  17.                 cache.read(finalI + "");
  18.             }, String.valueOf(i)).start();
  19.         }
  20.     }
  21. }
  22.  
  23. //模拟一个缓存资源类，有读写两种功能
  24. class MyCache {
  25.  
  26.     HashMap<String, String> map = new HashMap<>();
  27.  
  28.     ReentrantLock lock = new ReentrantLock();
  29.  
  30.     ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
  31.  
  32.     //读写都加锁
  33.     public void write(String key, String value) {
  34.         rwLock.writeLock().lock();
  35.         try {
  36.             System.out.println(Thread.currentThread().getName() + "线程开始写入数据...");
  37.             //延迟500ms模拟业务耗时，同时可以看出读写不能共同执行 (因为运行结果是先打印一个线程写入，再打印对应线程写入完成)
  38.             TimeUnit.MILLISECONDS.sleep(500);
  39.             map.put(key, value);
  40.             System.out.println(Thread.currentThread().getName() + "线程完成写入数据!");
  41.         } catch (InterruptedException e) {
  42.             e.printStackTrace();
  43.         } finally {
  44.             rwLock.writeLock().unlock();
  45.         }
  46.     }
  47.  
  48.     public void read(String key) {
  49.         rwLock.readLock().lock();
  50.         try {
  51.             System.out.println(Thread.currentThread().getName() + "线程开始读取数据...");
  52.             String val = map.get(key);
  53.             TimeUnit.MILLISECONDS.sleep(200);
  54.             System.out.println(Thread.currentThread().getName() + "线程读取到的数据是：\t" + val);
  55.         } catch (InterruptedException e) {
  56.             e.printStackTrace();
  57.         } finally {
  58.             rwLock.readLock().unlock();
  59.         }
  60.     }
  61. }
  62. 运行结果：
  63. 1线程开始写入数据...
  64. 1线程完成写入数据!
  65. 2线程开始写入数据...
  66. 2线程完成写入数据!
  67. 3线程开始写入数据...
  68. 3线程完成写入数据!
  69. 4线程开始写入数据...
  70. 4线程完成写入数据!
  71. 5线程开始写入数据...
  72. 5线程完成写入数据!
  73. 6线程开始写入数据...
  74. 6线程完成写入数据!
  75. 7线程开始写入数据...
  76. 7线程完成写入数据!
  77. 8线程开始写入数据...
  78. 8线程完成写入数据!
  79. 9线程开始写入数据...
  80. 9线程完成写入数据!
  81. 10线程开始写入数据...
  82. 10线程完成写入数据!
  83. 1线程开始读取数据...
  84. 9线程开始读取数据...
  85. 7线程开始读取数据...
  86. 6线程开始读取数据...
  87. 5线程开始读取数据...
  88. 3线程开始读取数据...
  89. 4线程开始读取数据...
  90. 2线程开始读取数据...
  91. 10线程开始读取数据...
  92. 8线程开始读取数据...
  93. 10线程读取到的数据是：10
  94. 4线程读取到的数据是：	4
  95. 2线程读取到的数据是：	2
  96. 8线程读取到的数据是：	8
  97. 3线程读取到的数据是：	3
  98. 7线程读取到的数据是：	7
  99. 6线程读取到的数据是：	6
  100. 5线程读取到的数据是：	5
  101. 1线程读取到的数据是：	1
  102. 9线程读取到的数据是：	9

说明：可以看出，所有写操作还是跟之前一样，全部互斥。但读操作可以并发读取。

结论

使用ReadWriteLock实现读写操作，一体两面，读写互斥，读读共享，但是读没有完成时候其它线程写锁无法获取

2.4 锁降级

ReentrantReadwriteLock锁降级:

  • 将写入锁降级为读锁(类似Linux文件读写权限理解，就像写权限要高于读权限一样)，锁的严苛程度变强叫做升级，反之叫做降级。

ReentrantReadwriteLock的特性：

写锁降级成为读锁

  1. 如果同一个线程持有了写锁，在没有释放写锁的情况下，它还可以继续获得读锁。这就是写锁的降级，降级成为了读锁。
  2. 规则惯例，先获取写锁，然后获取读锁，再释放写锁的次序。
  3. 如果释放了写锁，那么就完全转换为读锁。

总之：

  • 如果一个线程先获取写锁，在获取写锁和释放写锁之间可以再获取读锁，如果获取了读锁，之前获取的写锁且被释放了。那么之前的写锁，就降级为现在的读锁了。

why?要有这么个特性?

----后面解释，大概目的：锁降级是为了让当前线程感知到数据的变化，目的是保证数据的可见性

2.5 写锁可以降级为读锁，但读锁不可升级为写锁

重入还允许通过获取写入锁定，然后读取锁然后释放写锁从写锁到读取锁，但是从读锁升级到写锁是不可能的

锁降级的目的：锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性

样例1

锁降级：获取写锁 ——> 获取读锁 ——> 释放写锁 ——> 释放读锁      ✔ 可以完成

  1. import java.util.concurrent.locks.ReentrantReadWriteLock;
  2.  
  3. public class LockDownGradingDemo {
  4.  
  5.     public static void main(String[] args) {
  6.         ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  7.  
  8.         ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
  9.         ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
  10.  
  11.         // 例一：正常两个A、B线程
  12. //        new Thread(() -> {
  13. //            readLock.lock();
  14. //            System.out.println("---A线程读取---");
  15. //            readLock.unlock();
  16. //        }, "A").start();
  17. //
  18. //        new Thread(() -> {
  19. //            writeLock.lock();
  20. //            System.out.println("---B线程写入---");
  21. //            writeLock.unlock();
  22. //        }, "B").start();
  23.  
  24.  
  25.         // 例二：only one 同一个线程
  26.         writeLock.lock();
  27.         System.out.println("---写入---");
  28.         // 一些其它的业务操作...
  29.  
  30.         readLock.lock();
  31.         System.out.println("---读取---");
  32.         // 一些其它的业务操作...
  33.  
  34.         writeLock.unlock();
  35.         readLock.unlock();
  36.     }
  37.  
  38. }
  39.  
  40. 输出结果：
  41. ---写入---
  42. ---读取---

说明： 

  • 同一个线程的写后立刻读是可以的，即将写入锁降级为读锁是支持的，这种就是锁降级

样例2

锁降级：获取读锁 ——> 获取写锁 ——> 释放读锁 ——> 释放写锁      X 不可以完成

  1. import java.util.concurrent.locks.ReentrantReadWriteLock;
  2.  
  3. public class LockDownGradingDemo2 {
  4.  
  5.     public static void main(String[] args) {
  6.         ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  7.  
  8.         ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
  9.         ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
  10.  
  11.         // 例二：only one 同一个线程
  12.         readLock.lock();
  13.         System.out.println("---读取---");
  14.         // 一些其它的业务操作...
  15.  
  16.         writeLock.lock();
  17.         System.out.println("---写入---");
  18.         // 一些其它的业务操作...
  19.  
  20.         readLock.unlock(); // 这个位置和下面那个位置效果一样
  21.  
  22.         writeLock.unlock();
  23. //        readLock.unlock();
  24.     }
  25.  
  26. }
  27.  
  28.  
  29. 输出结果：
  30. ---读取---
  31. // ...程序未结束

说明：

  • 如果有线程读没有完成的时候，写线程无法获取锁，必须要等着读锁释放所锁后才有机会写，这是悲观锁的策略

1、2例子对比小结：

  • 其实想想很容易理解：同一个线程，先读，还没有读完(读锁readLock没有unlock)，我又去写。那么我之前的不就是脏数据了？因此应该先全部读完，才能执行写操作。
  • 而例子1中，先写，就算没写完(写锁没有释放)，我立马去读，由于读操作不会导致数据不一致。因此，这是合理的。

2.6 写锁和读锁是互斥的

        写锁和读锁是互斥的（这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要保持写操作的可见性。因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作

因此，分析读写锁ReentrantReadWriteLock，会发现它有个潜在的问题：

  • 即ReentrantReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，也就是写入必须等待，这是一种悲观的读锁，人家还在读着那，你先别去写，省的数据乱。

2.7 Oracle公司ReentrantReadWriteLock使用样例

  1. * <p><b>Sample usages</b>. Here is a code sketch showing how to perform
  2. * lock downgrading after updating a cache (exception handling is
  3. * particularly tricky when handling multiple locks in a non-nested
  4. * fashion):
  5. *
  6. * <pre> {@code
  7. * class CachedData {
  8. *   Object data;
  9. *   volatile boolean cacheValid;
  10. *   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
  11. *
  12. *   void processCachedData() {
  13. *     rwl.readLock().lock();// 1
  14. *     if (!cacheValid) {
  15. *       // Must release read lock before acquiring write lock
  16. *       rwl.readLock().unlock();// 2
  17. *       rwl.writeLock().lock();// 3
  18. *       try {
  19. *         // Recheck state because another thread might have
  20. *         // acquired write lock and changed state before we did.
  21. *         if (!cacheValid) {
  22. *           data = ...//在此做一些写操作
  23. *           cacheValid = true;
  24. *         }
  25. *         // Downgrade by acquiring read lock before releasing write lock
  26. *         rwl.readLock().lock();// 4
  27. *       } finally {
  28. *         rwl.writeLock().unlock(); // 5 Unlock write, still hold read
  29. *       }
  30. *     }
  31. *
  32. *     try {
  33. *       use(data);
  34. *     } finally {
  35. *       rwl.readLock().unlock();// 6
  36. *     }
  37. *   }
  38. * }}</pre>

代码解读：

  • 1-6 六个加锁/释放锁的操作。1-2对应读锁、3-5对应写锁、4-6对应读锁。volatile类型的cacheValid变量，保证其可见性
  • 首先，线程第一次进来，资源类CacheData是没有被修改过的。先加读锁1，if判断 ( !cacheValid ) 的值为true。在2的位置释放读锁。
  • 接着准备写操作，先获取写锁3。并进行双端检索 (防止其它线程恰好修改了)。做完写操作后，把cacheValid改为true。为了立刻读取到我刚刚修改的数据data，必须发生锁降级，在释放写锁5之前获取读锁4。原因：如果我先把写锁释放了，再获取读锁，出现了没有锁的空档期。在此期间锁可能被其他线程获取并修改数据，无法保证读锁立马能被同一个线程获取，可能在我使用data数据的期间，data数据又被修改了！
  • 在4的位置已经获取了读锁，代码运行到5的位置释放写锁。发生锁降级。之后在use(data)这行使用刚刚修改的data数据，最后在6位置释放读锁。让其他线程继续抢锁。

        这里只有锁降级才能保证，同一个线程我先执行写操作，再继续读我刚刚写的数据。在整个线程执行业务的过程中，一直是加锁(不是写锁就是读锁)状态，没有出现空档期，因此整个操作保证了原子性。

如果违背锁降级的步骤，如果违背锁降级的步骤， 如果违背锁降级的步骤

  • 如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁，那么假设此时另一个线程D获取了写锁并修改了数据，那么C线程无法感知到数据已被修改，则数据出现错误。

4 邮戳锁StampedLock

4.1 是什么？

StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化

stamp 代表了锁的状态。当stamp返回零时，表示线程获取锁失败，并且当释放锁或者转换锁的时候，都要传入最初获取的stamp值。

4.2 它是由饥饿问题引出

锁饥饿问题：

  • ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，因此当前有可能会一直存在读锁，而无法获得写锁。

如何解决锁饥饿问题：

  • 使用”公平“策略可以一定程度上缓解这个问题
  • 使用”公平“策略是以牺牲系统吞吐量为代价的
  • StampedLock类的乐观读锁方式--->采取乐观获取锁，其他线程尝试获取写锁时不会被阻塞，在获取乐观读锁后，还需要对结果进行校验

4.3 StampedLock的特点

  • 所有获取锁的方法，都返回一个邮戳，stamp为零表示失败，其余都表示成功
  • 所有释放锁的方法，都需要一个邮戳，这个stamp必须是和成功获取锁时得到的stamp一致
  • StampedLock是不可重入的，危险（如果一个线程已经持有了写锁，在去获取写锁的话会造成死锁）
  • StampedLock有三种访问模式：
    • Reading（悲观读模式）：功能和ReentrantReadWriteLock的读锁类似
    • Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似
    • Optimistic reading（乐观读模式）：无锁机制，类似与数据库中的乐观锁，支持读写并发，很乐观认为读时没人修改，假如被修改在实现升级为悲观读模式
  • 一句话：读的过程中也允许写锁介入

4.4 邮戳锁StampedLock代码演示

4.4.1 传统的读写锁模式——读的时候写锁不能获取

  1. import java.util.concurrent.TimeUnit;
  2. import java.util.concurrent.locks.StampedLock;
  3.  
  4. public class StampedLockDemo {
  5.  
  6.     static int number = 37;
  7.     static StampedLock stampedLock = new StampedLock();
  8.  
  9.     public void write() {
  10.         long stamp = stampedLock.writeLock();
  11.         System.out.println(Thread.currentThread().getName() + "\t" + "写线程准备修改");
  12.         try {
  13.             number = number + 13;
  14.         } finally {
  15.             stampedLock.unlockWrite(stamp);
  16.         }
  17.         System.out.println(Thread.currentThread().getName() + "\t" + "写线程结束修改");
  18.     }
  19.  
  20.     // 悲观锁，读没有完成时候写锁无法获得锁
  21.     public void read() {
  22.         long stamp = stampedLock.readLock();
  23.         System.out.println(Thread.currentThread().getName() + "\t" + "come in readLock code Block, 4 second continue...");
  24.         for (int i = 0; i < 4; i++) {
  25.             try {
  26.                 TimeUnit.SECONDS.sleep(1);
  27.             } catch (InterruptedException e) {
  28.                 e.printStackTrace();
  29.             }
  30.             System.out.println(Thread.currentThread().getName() + "\t" + "正在读取中");
  31.         }
  32.  
  33.         try {
  34.             int result = number;
  35.             System.out.println(Thread.currentThread().getName() + "\t" + "获得成员变量值result: " + result);
  36.             System.out.println("写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥");
  37.         } finally {
  38.             stampedLock.unlockRead(stamp);
  39.         }
  40.  
  41.     }
  42.  
  43.     public static void main(String[] args) {
  44.         StampedLockDemo resource = new StampedLockDemo();
  45.         new Thread(() -> resource.read(), "readThread").start();
  46.  
  47.         try {
  48.             TimeUnit.SECONDS.sleep(1);
  49.         } catch (InterruptedException e) {
  50.             e.printStackTrace();
  51.         }
  52.  
  53.         new Thread(() -> {
  54.             System.out.println(Thread.currentThread().getName() + "\t" + "come in");
  55.             resource.write();
  56.         }, "writeThread").start();
  57.         
  58.         try {
  59.             TimeUnit.SECONDS.sleep(4);
  60.         } catch (InterruptedException e) {
  61.             e.printStackTrace();
  62.         }
  63.  
  64.         System.out.println(Thread.currentThread().getName() + "\t" + "number:" + number);
  65.     }
  66.  
  67. }
  68.  
  69. 输出结果：
  70. readThread	come in readLock code Block, 4 second continue...
  71. readThread	正在读取中
  72. writeThread	come in
  73. readThread	正在读取中
  74. readThread	正在读取中
  75. readThread	正在读取中
  76. readThread	获得成员变量值result: 37
  77. 写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥
  78. writeThread	写线程准备修改
  79. writeThread	写线程结束修改
  80. main	number:50

这和之前的读写锁ReentrantLock使用类似，但邮戳锁不可重入

4.4.2 乐观读模式——读的过程中也允许写锁介入

  1. import java.util.concurrent.TimeUnit;
  2. import java.util.concurrent.locks.StampedLock;
  3.  
  4. public class StampedLockDemo2 {
  5.  
  6.     static int number = 37;
  7.     static StampedLock stampedLock = new StampedLock();
  8.  
  9.     public void write() {
  10.         long stamp = stampedLock.writeLock();
  11.         System.out.println(Thread.currentThread().getName() + "\t" + "写线程准备修改");
  12.         try {
  13.             number = number + 13;
  14.         } finally {
  15.             stampedLock.unlockWrite(stamp);
  16.         }
  17.         System.out.println(Thread.currentThread().getName() + "\t" + "写线程结束修改");
  18.     }
  19.  
  20.     // 乐观读，读的过程中也允许写锁介入
  21.     public void read() {
  22.         long stamp = stampedLock.tryOptimisticRead();
  23.  
  24.         int result = number;
  25.  
  26.         // public boolean validate(long stamp)方法官方解释
  27.         // 如果自发出给定标记后未完全获取锁，则返回true。如果标记为零，则始终返回false。如果图章代表当前持有的锁，则始终返回true。 使用未从tryOptimisticRead()获取的值或此锁定的锁定方法调用此方法没有定义的效果或结果
  28.         System.out.println("4秒前 stampedLock.validate方法值（true 无修改 false有修改）" + "\t" + stampedLock.validate(stamp));
  29.  
  30.         // 故意间隔4秒钟，很乐观认为读取中没有其它线程修改过number值，具体靠判断
  31.         for (int i = 0; i < 4; i++) {
  32.             try {
  33.                 TimeUnit.SECONDS.sleep(1);
  34.             } catch (InterruptedException e) {
  35.                 e.printStackTrace();
  36.             }
  37.             System.out.println(Thread.currentThread().getName() + "\t" + " 正在读取...." + i + "秒后，stampedLock.validate方法值（true 无修改 false有修改）" + "\t" + stampedLock.validate(stamp));
  38.         }
  39.  
  40.         if (!stampedLock.validate(stamp)) {
  41.             System.out.println("有人修改----------有写操作");
  42.             stamp = stampedLock.readLock();
  43.             try {
  44.                 System.out.println("从乐观读升级为悲观读");
  45.                 result = number;
  46.                 System.out.println("重新悲观读后result：" + result);
  47.             } finally {
  48.                 stampedLock.unlockRead(stamp);
  49.             }
  50.         }
  51.         System.out.println(Thread.currentThread().getName() + "\t" + "finally value: " + result);
  52.  
  53.     }
  54.  
  55.  
  56.     public static void main(String[] args) {
  57.         StampedLockDemo2 resource = new StampedLockDemo2();
  58.         new Thread(resource::read, "readThread").start();
  59.  
  60.         // 暂停2秒线程，演示读过程可以写介入
  61.         // 如果暂停>4秒线程，这样读过程没有写介入，此时输出finally value：37
  62.         try {
  63.             TimeUnit.SECONDS.sleep(2);
  64.         } catch (InterruptedException e) {
  65.             e.printStackTrace();
  66.         }
  67.  
  68.         new Thread(() -> {
  69.             System.out.println(Thread.currentThread().getName() + "\t" + " come in");
  70.             resource.write();
  71.         }, "writeThread").start();
  72.     }
  73.  
  74. }
  75.  
  76. 输出结果：
  77. 4秒前 stampedLock.validate方法值（true 无修改 false有修改）	true
  78. readThread	 正在读取....0秒后，stampedLock.validate方法值（true 无修改 false有修改）	true
  79. writeThread	 come in
  80. writeThread	写线程准备修改
  81. writeThread	写线程结束修改
  82. readThread	 正在读取....1秒后，stampedLock.validate方法值（true 无修改 false有修改）	false
  83. readThread	 正在读取....2秒后，stampedLock.validate方法值（true 无修改 false有修改）	false
  84. readThread	 正在读取....3秒后，stampedLock.validate方法值（true 无修改 false有修改）	false
  85. 有人修改----------有写操作
  86. 从乐观读升级为悲观读
  87. 重新悲观读后result：50
  88. readThread	finally value: 50

4.5 StampedLock的缺点

  • StampedLock不支持重入，没有Re开头
  • StampedLock的悲观读锁和写锁都不支持条件变量，这个也需要主要
  • 使用StampedLock一定不要调用中断操作，即不要调用interrupt()方法
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/956239
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号