• 读写锁ReentrantReadWriteLock&StampLock详解

            如何设计一把读写锁？ReentrantReadWriteLock

        读写锁设计思路

            读写状态的设计

            设计的精髓：用一个变量如何维护多种状态

            在 ReentrantLock 中，使用 Sync ( 实际是 AQS )的 int 类型的 state 来表示同步状态，表示锁被一个线程重复获取的次数。但是，读写锁 ReentrantReadWriteLock 内部维护着一对读写锁，如果要用一个变量维护多种状态，需要采用“按位切割使用”的方式来维护这个变量，将其切分为两部分：高16为表示读，低16为表示写。

            分割之后，读写锁是如何迅速确定读锁和写锁的状态呢？通过位运算。假如当前同步状态为S，那么：

           1. 写状态，等于 S & 0x0000FFFF（将高 16 位全部抹去）。 当写状态加1，等于S+1.

           2. 读状态，等于 S >>> 16 (无符号补 0 右移 16 位)。当读状态加1，等于S+（1<<16）

            根据状态的划分能得出一个推论：S不等于0时，当写状态（S&0x0000FFFF）等于0时，则读状态（S>>>16）大于0，即读锁已被获取。\

            代码实现

            java.util.concurrent.locks.ReentrantReadWriteLock.Sync

    exclusiveCount(int c)
    静态方法，获得持有写状态的锁的次数。
    sharedCount(int c)
    静态方法，获得持有读状态的锁的数量。不同于写锁，读锁可以同时被多个线程持有。而 每个线程持有的读锁支持重入的特性，所以需要对每个线程持有的读锁的数量单独计数，这就需要用到HoldCounter 计数器

            HoldCounter 计数器

            读锁的内在机制其实就是一个共享锁。一次共享锁的操作就相当于对HoldCounter 计数器的操作。获取共享锁，则该计数器 + 1，释放共享锁，该计数器 - 1。只有当线程获取共享锁后才能对共享锁进行释放、重入操作。

            通过 ThreadLocalHoldCounter 类，HoldCounter 与线程进行绑定。HoldCounter 是绑定线程的一个计数器，而 ThreadLocalHoldCounter 则是线程绑定的 ThreadLocal。

            HoldCounter是用来记录读锁重入数的对象

            ThreadLocalHoldCounter是ThreadLocal变量，用来存放不是第一个获取读锁的线程的其他线程的读锁重入数对象

    1. 读写锁介绍

            读写锁ReadWriteLock，顾名思义一把锁分为读与写两部分，读锁允许多个线程同时获得，因为读操作本身是线程安全的。而写锁是互斥锁，不允许多个线程同时获得写锁。并且读与写操作也是互斥的。读写锁适合多读少写的业务场景。

    2. ReentrantReadWriteLock介绍 

            针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它内部，维护了一对相关的锁，一个用于只读操作，称为读锁；一个用于写入操作，称为写锁，描述如下：

    线程进入读锁的前提条件：
            1、没有其他线程的写锁
            2、没有写请求或者有写请求，但调用线程和持有锁的线程是同一个 。
    线程进入写锁的前提条件：
            1、没有其他线程的读锁
            2、没有其他线程的写锁
    而读写锁有以下三个重要的特性：
            1、 公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。
            2、可重入 ：读锁和写锁都支持线程重入。以读写线程为例： 读线程获取读锁后，能够再次获取读锁。写线程在获取 写锁之后能够再次获取写锁，同时也可以获取读锁。
            3、锁降级 ： 遵循获取写锁、再获取读锁最后释放写锁的次序，写锁能够降级成为读锁 。

    2.1 ReentrantReadWriteLock的使用

    读写锁接口ReadWriteLock
    一对方法，分别获得读锁和写锁 Lock 对象。
    ReentrantReadWriteLock类结构
    ReentrantReadWriteLock是可重入的读写锁实现类 。在它内部，维护了一对相关的锁，一个用于
    只读操作，另一个用于写入操作。只要没有 Writer 线程，读锁可以由多个 Reader 线程同时持有。也
    就是说， 写锁是独占的，读锁是共享的。

    2.2 如何使用读写锁 

    1. package com.laoyang.Thread.readwritelock;
    2.  
    3. import java.util.concurrent.locks.Lock;
    4. import java.util.concurrent.locks.ReadWriteLock;
    5. import java.util.concurrent.locks.ReentrantReadWriteLock;
    6.  
    7. public class ReadWriteLockExample {
    8.     private final ReadWriteLock lock = new ReentrantReadWriteLock();
    9.     private final Lock readLock = lock.readLock();//读锁  共享锁
    10.     private final Lock writeLock = lock.writeLock();//写锁
    11.     private final String[] data = new String[10];
    12.  
    13.     public void write(int index, String value) {
    14.         writeLock.lock();
    15.         try {
    16.             System.out.println(Thread.currentThread().getName()+"获取写锁");
    17.             try {
    18.                 Thread.sleep(5000);
    19.             } catch (InterruptedException e) {
    20.                 throw new RuntimeException(e);
    21.             }
    22.             read(2);
    23.             data[index] = value;
    24.         } finally {
    25.             System.out.println(Thread.currentThread().getName()+"释放写锁");
    26.             writeLock.unlock();
    27.         }
    28.     }
    29.  
    30.     public String read(int index) {
    31.         readLock.lock();
    32.         try {
    33.             System.out.println(Thread.currentThread().getName()+"获取读锁");
    34.             try {
    35.                 Thread.sleep(3000);
    36.             } catch (InterruptedException e) {
    37.                 throw new RuntimeException(e);
    38.             }
    39.             return data[index];
    40.         } finally {
    41.             System.out.println(Thread.currentThread().getName()+"释放读锁");
    42.             readLock.unlock();
    43.         }
    44.     }
    45.  
    46.     public static void main(String[] args) {
    47.         ReadWriteLockExample rwl = new ReadWriteLockExample();
    48.         // 测试读读，读写，写写场景
    49. //        new Thread(()->{
    50. //            //rwl.read(2);
    51. //            rwl.write(2,"rwl");
    52. //          //  rwl.read(2);
    53. //        }).start();
    54.  
    55.         //测试读读
    56. //        new Thread(()->rwl.read(2)).start();
    57. //        new Thread(()->rwl.read(2)).start();
    58. //        new Thread(()->rwl.write(2,"rwl")).start();
    59.         //测试写写
    60.         new Thread(()->rwl.write(2,"rwl")).start();
    61.         new Thread(()->rwl.write(2,"rwl")).start();
    62.  
    63.  
    64.     }
    65. }

    2.3 注意事项

            读锁不支持条件变量

            重入时升级不支持：持有读锁的情况下去获取写锁，会导致获取永久等待
            重入时支持降级： 持有写锁的情况下可以去获取读锁

    2.4 应用场景

            以下是使用ReentrantReadWriteLock的常见场景：

                    1、读多写少：ReentrantReadWriteLock适用于读操作比写操作频繁的场景，因为它允许多个读线程同时访问共享数据，而写操作是独占的。

                    2、缓存：ReentrantReadWriteLock可以用于实现缓存，因为它可以有效地处理大量的读操作，同时保护缓存数据的一致性。

    读写锁在缓存中的应用
    1. package com.laoyang.Thread.readwritelock;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5. import java.util.concurrent.locks.Lock;
    6. import java.util.concurrent.locks.ReentrantReadWriteLock;
    7.  
    8. public class Cache {
    9.     static Map map = new HashMap();
    10.     static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    11.     static Lock r = rwl.readLock();
    12.     static Lock w = rwl.writeLock();
    13.  
    14.     // 获取一个key对应的value
    15.     public static final Object get(String key) {
    16.         r.lock();
    17.         try {
    18.             return map.get(key);
    19.         } finally {
    20.             r.unlock();
    21.         }
    22.     }
    23.  
    24.     // 设置key对应的value，并返回旧的value
    25.     public static final Object put(String key, Object value) {
    26.         w.lock();
    27.         try {
    28.             return map.put(key, value);
    29.         } finally {
    30.             w.unlock();
    31.         }
    32.     }
    33.  
    34.     // 清空所有的内容
    35.     public static final void clear() {
    36.         w.lock();
    37.         try {
    38.             map.clear();
    39.         } finally {
    40.             w.unlock();
    41.         }
    42.     }
    43.  
    44.  
    45.  
    46. }
            上述示例中，Cache组合一个非线程安全的HashMap作为缓存的实现，同时使用读写锁的读锁和写锁来保证Cache是线程安全的。在读操作get(String key)方法中，需要获取读锁，这使得并发访问该方法时不会被阻塞。写操作put(String key,Object value)方法和clear()方法，在更新 HashMap时必须提前获取写锁，当获取写锁后，其他线程对于读锁和写锁的获取均被阻塞，而 只有写锁被释放之后，其他读写操作才能继续。 Cache使用读写锁提升读操作的并发性，也保证每次写操作对所有的读写操作的可见性，同时简化了编程方式。

    3. 锁降级 

            锁降级指的是写锁降级成为读锁。如果当前线程拥有写锁，然后将其释放，最后再获取读锁，这种分段完成的过程不能称之为锁降级。锁降级是指把持住（当前拥有的）写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。锁降级可以帮助我们拿到当前线程修改后的结果而不被其他线程所破坏，防止更新丢失。

    3.1 锁降级的使用示例       
            因为数据不常变化，所以多个线程可以并发地进行数据处理，当数据变更后，如果当前线程感知到数 据变化，则进行数据的准备工作，同时其他处理线程被阻塞，直到当前线程完成数据的准备工作。
            
            锁降级中读锁的获取是否必要呢？答案是必要的。主要是为了保证数据的可见性 ，如果当前线程不获取读锁而是直接释放写锁，假设此刻另一个线程（记作线程T）获取了写锁并修改了数据，那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁，即遵循锁降级的步骤，则线程T将会被阻塞，直到当前线程使用数据并释放读锁之后，线程T才能获取写锁进行数据更新。
            RentrantReadWriteLock不支持锁升级 （把持读锁、获取写锁，最后释放读锁的过程）。目的也是保证数据可见性，如果读锁已被多个线程获取，其中任意线程成功获取了写锁并更新了数据，则其更新对其他获取到读锁的线程是不可见的。
    美团面试三连
    面试官：了解锁吗？
    小明：了解，还经常用过。
    面试官：说说synchronized和lock的区别吧
    小明：synchronized是可重入锁，由于lock是一个接口，重入性取决于实现，synchronized不支持中
    断，而lock可以。。。。。。。。。。。。。。。。 面试官：好了，那有没有比这两种锁更快的锁呢？
    小明：在读多写少的情况下，读写锁比他们的效率更高。
    面试官：那有没有比读写锁更快的锁呢？
    小明：。。。。。。。。。。

     

    4. StampedLock介绍 

            如果我们深入分析ReentrantReadWriteLock，会发现它有个潜在的问题：如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，即读的过程中不允许写，这是一种悲观的读锁。
    为了进一步提升并发执行效率，Java 8引入了新的读写锁： StampedLock 。
            StampedLock和ReentrantReadWriteLock相比，改进之处在于： 读的过程中也允许获取写锁后 写入！在原先读写锁的基础上新增了一种叫乐观读（Optimistic Reading）的模式。该模式并不会加锁，所以不会阻塞线程，会有更高的吞吐量和更高的性能。

            4.1 StampedLock的使用

            StampLock三种访问模式
            Writing（独占写锁）：writeLock 方法会使线程阻塞等待独占访问，可类比ReentrantReadWriteLock 的写锁模式，同一时刻有且只有一个写线程获取锁资源；
            Reading（悲观读锁）：readLock方法，允许多个线程同时获取悲观读锁，悲观读锁与独占写锁互斥，与乐观读共享。
            Optimistic Reading（乐观读）：这里需要注意了， 乐观读并没有加锁 ，也就是不会有 CAS 机制并且没有阻塞线程。仅当当前未处于 Writing 模式 tryOptimisticRead 才会返回非 0 的邮戳（Stamp）， 如果在获取乐观读之后没有出现写模式线程获取锁，则在方法validate返回 true ，允许多个线程获取乐观读以及读锁，同时允许一个写线程获取写锁。
            最好使用如下模板,否则容易出现bug：
             思考： 为何 StampedLock 性比 ReentrantReadWriteLock 好？
            关键在于StampedLock 提供的乐观读。ReentrantReadWriteLock 支持多个线程同时获取读锁，但是当多个线程同时读的时候，所有的写线程都是阻塞的。 StampedLock 的乐观读允许一个写线程获 取写锁，所以不会导致所有写线程阻塞，也就是当读多写少的时候，写线程有机会获取写锁，减少了 线程饥饿的问题，吞吐量大大提高。
             思考： 允许多个乐观读和一个写线程同时进入临界资源操作，那读取的数据可能是错的怎么办？
            
    乐观读不能保证读取到的数据是最新的，所以将数据读取到局部变量的时候需要通过lock.validate(stamp) 校验是否被写线程修改过，若是修改过则需要上悲观读锁，再重新读取数据到局部变量。

    4.2 演示乐观读

    1. package com.laoyang.Thread.readwritelock;
    2.  
    3.  
    4. import java.util.concurrent.locks.StampedLock;
    5.  
    6.  
    7. /**
    8.  * @author Fox
    9.  */
    10. public class StampedLockTest {
    11.  
    12.     public static void main(String[] args) throws InterruptedException {
    13.         Point point = new Point();
    14.  
    15.         //第一次移动x,y
    16.         new Thread(() -> point.move(100, 200)).start();
    17.         Thread.sleep(100);
    18.         new Thread(() -> point.distanceFromOrigin()).start();
    19.         Thread.sleep(500);
    20.         //第二次移动x,y
    21.         new Thread(()-> point.move(300,400)).start();
    22.  
    23.     }
    24. }
    25.  
    26.  
    27. class Point {
    28.     private final StampedLock stampedLock = new StampedLock();
    29.  
    30.     private double x;
    31.     private double y;
    32.  
    33.     public void move(double deltaX, double deltaY) {
    34.         // 获取写锁
    35.         long stamp = stampedLock.writeLock();
    36.         System.out.println("获取到writeLock");
    37.         try {
    38.             x += deltaX;
    39.             y += deltaY;
    40.         } finally {
    41.             // 释放写锁
    42.             stampedLock.unlockWrite(stamp);
    43.  
    44.             System.out.println(("释放writeLock"));
    45.         }
    46.     }
    47.  
    48.     /**
    49.      * 计算当前坐标到原点的距离
    50.      * 乐观读
    51.      * @return
    52.      */
    53.     public double distanceFromOrigin() {
    54.         // 获得一个乐观读  (无锁)
    55.         long stamp = stampedLock.tryOptimisticRead();
    56.         // 注意下面两行代码不是原子操作
    57.         // 假设x,y = (100,200)
    58.         // 此处已读取到x=100，但x,y可能被写线程修改为(300,400)
    59.         double currentX = x;
    60.         System.out.println("第1次读，x:{},y:{},currentX:{}" + x + y+ currentX);
    61.         try {
    62.             Thread.sleep(2000);
    63.         } catch (InterruptedException e) {
    64.             e.printStackTrace();
    65.         }
    66. //         此处已读取到y，如果没有写入，读取是正确的(100,200)
    67. //         如果有写入，读取是错误的(100,400)
    68.         double currentY = y;
    69.         System.out.println("第2次读，x:{},y:{},currentX:{},currentY:{}"+
    70.                 x+ y+ currentX+ currentY);
    71.  
    72.  
    73.         // 检查乐观读锁后是否有其他写锁发生
    74.         if (!stampedLock.validate(stamp)) {
    75.             // 获取一个悲观读锁
    76.             stamp = stampedLock.readLock();
    77.             try {
    78.                 currentX = x;
    79.                 currentY = y;
    80.  
    81.                 System.out.println("最终结果，x:{},y:{},currentX:{},currentY:{}"+
    82.                         x+ y+ currentX+ currentY);
    83.             } finally {
    84.                 // 释放悲观读锁
    85.                 stampedLock.unlockRead(stamp);
    86.             }
    87.         }
    88.         return Math.sqrt(currentX * currentX + currentY * currentY);
    89.     }
    90.  
    91.  
    92.  
    93. }

    4.3 使用场景和注意事项

            对于读多写少的高并发场景 StampedLock的性能很好，通过乐观读模式很好的解决了写线程“饥饿”的问题，我们可以使用StampedLock 来代替ReentrantReadWriteLock ，但是需要注意的是 StampedLock 的功能仅仅是 ReadWriteLock 的子集，在使用的时候，还是有几个地方需要注意一下。

           1、 StampedLock 写锁是不可重入的，如果当前线程已经获取了写锁，再次重复获取的话就会死锁，使用过程中一定要注意；

            2、悲观读、写锁都不支持条件变量 Conditon ，当需要这个特性的时候需要注意；

            3. 如果线程阻塞在 StampedLock 的 readLock() 或者 writeLock() 上时，此时调用该阻塞线程的 interrupt() 方法，会导致 CPU 飙升。所以，使用 StampedLock 一定不要调用中断操作，如果需要支持中断功能，一定使用可中断的悲观读锁 readLockInterruptibly() 和写锁 writeLockInterruptibly()。

  • 相关阅读:
    Notepad++插件 Hex-Edit
    Vue的生命周期函数有哪些？详细说明
    力扣 -- 376. 摆动序列
    软件测试人需要掌握的测试知识架构体系（上）
    vivado HW_SYSMON
    C++ LibCurl实现Web指纹识别
    Python 正则表达式进阶与实战
    还在担心报表不好做？不用怕，试试这个方法（三）
    JAX计算SeLU函数
    小米手环8pro重新和手机配对解决办法
  • 原文地址：https://blog.csdn.net/qq_67801847/article/details/133842397