• 读锁被唤醒时，会去判断队列里面自己的下一个节点是否也是读锁(shard属性)，如果是就会一起唤醒，直到遇到一个写锁就终止。iShot2021-01-31 23.56.25.png
    1. import java.util.concurrent.TimeUnit;
    2. import java.util.concurrent.locks.Condition;
    3. import java.util.concurrent.locks.Lock;
    4. import java.util.concurrent.locks.ReentrantLock;
    5. import java.util.concurrent.locks.ReentrantReadWriteLock;
    7. @Slf4j(topic = "enjoy")
    8. public class Lock2 {
    9.     //读写锁
    10.     static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    12.     static Lock r = rwl.readLock();
    13.     static Lock w = rwl.writeLock();
    15.     public static void main(String[] args) throws InterruptedException {
    16.         /**
    17.          * t1  最先拿到写（W）锁 然后睡眠了5s
    18.          * 之后才会叫醒别人
    19.          */
    20.         Thread t1 = new Thread(() -> {
    21.             w.lock();
    22.             try {
    23.                 log.debug("t1 +");
    24.                 TimeUnit.SECONDS.sleep(5);
    25.                 log.debug("5s 之后");
    26.             } catch (InterruptedException e) {
    27.                 e.printStackTrace();
    28.             } finally {
    29.                 w.unlock();
    30.             }
    31.         }, "t1");
    32.         t1.start();
    33.         TimeUnit.SECONDS.sleep(1);
    35.         /**
    36.          * t1在睡眠的过程中 t2不能拿到 读写互斥
    37.          * t2 一直阻塞
    38.          */
    39.         Thread t2 = new Thread(() -> {
    40.             try {
    41.                 r.lock();
    42.                 log.debug("t2----+锁-------");
    43.                 TimeUnit.SECONDS.sleep(1);
    44.             } catch (Exception e) {
    46.                 e.printStackTrace();
    47.             } finally {
    48.                 log.debug("t2-----解锁-------");
    49.                 r.unlock();
    50.             }
    51.         }, "t2");
    52.         t2.start();
    53.         TimeUnit.SECONDS.sleep(1);
    54.         /**
    55.          * t1在睡眠的过程中 t3不能拿到 读写互斥
    56.          * t3 一直阻塞
    57.          * 当t1释放锁之后 t3和t2 能同时拿到锁
    58.          * 读读并发
    59.          */
    60.         Thread t3 = new Thread(() -> {
    61.             try {
    62.                 r.lock();
    63.                 log.debug("t3----+锁-------");
    64.                 TimeUnit.SECONDS.sleep(1);
    65.             } catch (Exception e) {
    66.                 e.printStackTrace();
    67.             } finally {
    68.                 log.debug("t3----释放-------");
    70.                 r.unlock();
    71.             }
    72.         }, "t3");
    74.         t3.start();
    76.         /**
    77.          * 拿写锁
    78.          * t1睡眠的时候 t4也页阻塞
    79.          * 顺序应该 t2 t3  t4
    80.          */
    81.         Thread t4 = new Thread(() -> {
    82.             try {
    83.                 w.lock();
    84.                 log.debug("t4--------+---");
    85.                 TimeUnit.SECONDS.sleep(10);
    86.                 log.debug("t4--------醒来---");
    87.             } catch (Exception e) {
    88.                 e.printStackTrace();
    89.             } finally {
    90.                 log.debug("t4--------解锁---");
    91.                 w.unlock();
    92.             }
    93.         }, "t4");
    95.         t4.start();
    97.         /**
    98.          *
    99.          * t5 是读锁
    100.          * 他会不会和t2 t3 一起执行
    101.          */
    103.         Thread t5 = new Thread(() -> {
    104.             try {
    105.                 r.lock();
    106.                 log.debug("t5--------+锁---");
    107.             } catch (Exception e) {
    108.                 e.printStackTrace();
    109.             } finally {
    110.                 log.debug("t5--------解锁---");
    111.                 r.unlock();
    112.             }
    113.         }, "t5");
    115.         t5.start();
    116.     }
    117. }