• （八） 共享模型之管程【ReentrantLock】

    相对于 synchronized 具备如下特定：

    （1）可中断

    （2）可以设置超时时间

    （3）可以设置为公平锁

    （4）支持多个条件变量

    与 synchronized 一样，都支持可重入

     基本语法

    一、可重入（P121）

    可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁。

    如果是不可重入，那么第二次获得锁时，自己也会被锁挡住。

    1. @Slf4j(topic = "c.Test22")
    2. public class Test22 {
    3.  
    4.     private static ReentrantLock lock = new ReentrantLock();
    5.  
    6.     public static void main(String[] args) {
    7.         lock.lock();
    8.         try {
    9.             log.debug("enter main");
    10.             m1();
    11.         } finally {
    12.             lock.unlock();
    13.         }
    14.     }
    15.  
    16.     public static void m1(){
    17.         lock.lock();
    18.         try {
    19.             log.debug("enter m1");
    20.             m2();
    21.         } finally {
    22.             lock.unlock();
    23.         }
    24.     }
    25.  
    26.     public static void m2(){
    27.         lock.lock();
    28.         try {
    29.             log.debug("enter m2");
    30.         } finally {
    31.             lock.unlock();
    32.         }
    33.     }
    34. }

    二、可打断

    1. @Slf4j(topic = "c.Test22")
    2. public class Test22 {
    3.  
    4.     private static ReentrantLock lock = new ReentrantLock();
    5.  
    6.     public static void main(String[] args) throws InterruptedException {
    7.  
    8.         Thread t1 = new Thread(() -> {
    9.             try {
    10.                 //如果没有竞争那么此方法就会获取lock对象锁
    11.                 //如果有竞争就进入阻塞队列，可以被其它线程用interruput方法打断
    12.                 log.debug("尝试获取锁");
    13.                 lock.lockInterruptibly();
    14.             } catch (InterruptedException e) {
    15.                 e.printStackTrace();
    16.                 log.debug("没有获得锁，返回");
    17.                 return;
    18.             }
    19.             try {
    20.                 log.debug("获取到锁");
    21.             } finally {
    22.                 lock.unlock();
    23.             }
    24.         },"t1");
    25.  
    26.         lock.lock();
    27.         t1.start();
    28.  
    29.         Thread.sleep(1000);
    30.         log.debug("打断 t1");
    31.         t1.interrupt();
    32.     }
    33. }
    注意如果是 不可中断（lock()方法）模式，那么即使使用了 interrupt 也不会让等待中断

    三、锁超时

    1. @Slf4j(topic = "c.Test22")
    2. public class Test22 {
    3.  
    4.     private static ReentrantLock lock = new ReentrantLock();
    5.  
    6.     public static void main(String[] args) throws InterruptedException {
    7.  
    8.         Thread t1 = new Thread(() -> {
    9.             log.debug("尝试获取锁");
    10.             // 立刻尝试获取锁
    11.             boolean tryLock = lock.tryLock();
    12.             if (!tryLock){
    13.                 log.debug("获取不到锁");
    14.                 return;
    15.             }
    16.             try {
    17.                 log.debug("获得到锁");
    18.             } finally {
    19.                 lock.unlock();
    20.             }
    21.         },"t1");
    22.  
    23.         log.debug("获取锁");
    24.         lock.lock();
    25.         t1.start();
    26.     }
    27. }

    1. @Slf4j(topic = "c.Test22")
    2. public class Test22 {
    3.  
    4.     private static ReentrantLock lock = new ReentrantLock();
    5.  
    6.     public static void main(String[] args) throws InterruptedException {
    7.  
    8.         Thread t1 = new Thread(() -> {
    9.             log.debug("尝试获取锁");
    10.             try {
    11.                 // 2s后尝试获取锁
    12.                 boolean tryLock = lock.tryLock(2, TimeUnit.SECONDS);
    13.                 if (!tryLock){
    14.                     log.debug("获取不到锁");
    15.                     return;
    16.                 }
    17.             } catch (InterruptedException e) {
    18.                 e.printStackTrace();
    19.                 log.debug("获取不到锁");
    20.                 return;
    21.             }
    22.             try {
    23.                 log.debug("获得到锁");
    24.             } finally {
    25.                 lock.unlock();
    26.             }
    27.         },"t1");
    28.  
    29.         log.debug("获取锁");
    30.         lock.lock();
    31.         t1.start();
    32.     }
    33. }

    使用 tryLock 解决哲学家就餐问题 
    1. @Slf4j(topic = "c.Test23")
    2. public class Test23 {public static void main(String[] args) {
    3.     Chopstick c1 = new Chopstick("1");
    4.     Chopstick c2 = new Chopstick("2");
    5.     Chopstick c3 = new Chopstick("3");
    6.     Chopstick c4 = new Chopstick("4");
    7.     Chopstick c5 = new Chopstick("5");
    8.     new Philosopher("苏格拉底", c1, c2).start();
    9.     new Philosopher("柏拉图", c2, c3).start();
    10.     new Philosopher("亚里士多德", c3, c4).start();
    11.     new Philosopher("赫拉克利特", c4, c5).start();
    12.     new Philosopher("阿基米德", c5, c1).start();
    13. }
    14. }
    15.  
    16. @Slf4j(topic = "c.Philosopher")
    17. class Philosopher extends Thread {
    18.     Chopstick left;
    19.     Chopstick right;
    20.  
    21.     public Philosopher(String name, Chopstick left, Chopstick right) {
    22.         super(name);
    23.         this.left = left;
    24.         this.right = right;
    25.     }
    26.  
    27.     @Override
    28.     public void run() {
    29.         while (true) {
    30.             //　尝试获得左手筷子
    31.             if(left.tryLock()) {
    32.                 try {
    33.                     // 尝试获得右手筷子
    34.                     if(right.tryLock()) {
    35.                         try {
    36.                             eat();
    37.                         } finally {
    38.                             right.unlock();
    39.                         }
    40.                     }
    41.                 } finally {
    42.                     left.unlock(); // 释放自己手里的筷子
    43.                 }
    44.             }
    45.         }
    46.     }
    47.  
    48.     Random random = new Random();
    49.     private void eat() {
    50.         log.debug("eating...");
    51.         Sleeper.sleep(0.5);
    52.     }
    53. }
    54.  
    55. class Chopstick extends ReentrantLock {
    56.     String name;
    57.  
    58.     public Chopstick(String name) {
    59.         this.name = name;
    60.     }
    61.  
    62.     @Override
    63.     public String toString() {
    64.         return "筷子{" + name + '}';
    65.     }
    66. }

    四、公平锁

    ReentrantLock 默认是不公平的 
    1.  
    2. // true：公平
    3. // false（默认）：不公平
    4. ReentrantLock lock = new ReentrantLock(true);

    公平锁一般没有必要，会降低并发度，后面分析原理时会讲解。

    五、条件变量

    synchronized 中也有条件变量，就是我们讲原理的 waitSet 休息室，当条件不满足时进入等待。

    ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比：

    （1）synchronized 是那些不满足条件的线程都在一间休息室等消息

    （2）而 ReentrantLock 支持多间休息室，唤醒时也是按休息室来唤醒的

    使用要点：

    （1）await 前需要获得锁

    （2）await 执行后，会释放锁，进入 conditionObject 等待

    （3）await 的线程被唤醒（或打断、或超时）去重新竞争 lock 锁

    （4）竞争 lock 锁成功后，从 await 后继续执行

    1. @Slf4j(topic = "c.Test22")
    2. public class Test22 {
    3.  
    4.     private static ReentrantLock lock = new ReentrantLock();
    5.  
    6.     public static void main(String[] args) throws InterruptedException {
    7.  
    8.         // 创建一个新的条件变量（休息室）
    9.         Condition condition1 = lock.newCondition();
    10.         Condition condition2 = lock.newCondition();
    11.  
    12.         lock.lock();
    13.         // 进入休息室等待
    14.         condition1.await();
    15.  
    16.         condition1.signal();
    17.         condition1.signalAll();
    18.  
    19.     }
    20. }
    1. @Slf4j(topic = "c.Test24")
    2. public class Test24 {
    3.     static final Object room = new Object();
    4.     static boolean hasCigarette = false;
    5.     static boolean hasTakeout = false;
    6.     static ReentrantLock ROOM = new ReentrantLock();
    7.     // 等待烟的休息室
    8.     static Condition waitCigaretteSet = ROOM.newCondition();
    9.     // 等外卖的休息室
    10.     static Condition waitTakeoutSet = ROOM.newCondition();
    11.  
    12.     public static void main(String[] args) {
    13.  
    14.  
    15.         new Thread(() -> {
    16.             ROOM.lock();
    17.             try {
    18.                 log.debug("有烟没？[{}]", hasCigarette);
    19.                 while (!hasCigarette) {
    20.                     log.debug("没烟，先歇会！");
    21.                     try {
    22.                         waitCigaretteSet.await();
    23.                     } catch (InterruptedException e) {
    24.                         e.printStackTrace();
    25.                     }
    26.                 }
    27.                 log.debug("可以开始干活了");
    28.             } finally {
    29.                 ROOM.unlock();
    30.             }
    31.         }, "小南").start();
    32.  
    33.         new Thread(() -> {
    34.             ROOM.lock();
    35.             try {
    36.                 log.debug("外卖送到没？[{}]", hasTakeout);
    37.                 while (!hasTakeout) {
    38.                     log.debug("没外卖，先歇会！");
    39.                     try {
    40.                         waitTakeoutSet.await();
    41.                     } catch (InterruptedException e) {
    42.                         e.printStackTrace();
    43.                     }
    44.                 }
    45.                 log.debug("可以开始干活了");
    46.             } finally {
    47.                 ROOM.unlock();
    48.             }
    49.         }, "小女").start();
    50.  
    51.         sleep(1);
    52.         new Thread(() -> {
    53.             ROOM.lock();
    54.             try {
    55.                 hasTakeout = true;
    56.                 waitTakeoutSet.signal();
    57.             } finally {
    58.                 ROOM.unlock();
    59.             }
    60.         }, "送外卖的").start();
    61.  
    62.         sleep(1);
    63.  
    64.         new Thread(() -> {
    65.             ROOM.lock();
    66.             try {
    67.                 hasCigarette = true;
    68.                 waitCigaretteSet.signal();
    69.             } finally {
    70.                 ROOM.unlock();
    71.             }
    72.         }, "送烟的").start();
    73.     }
    74.  
    75. }

    六、同步模式之顺序控制

    1. 固定运行顺序

    1.1 wait notify 版

    1. @Slf4j(topic = "c.Test25")
    2. public class Test25 {
    3.     static final Object lock = new Object();
    4.     // 表示 t2 是否运行过
    5.     static boolean t2runned = false;
    6.  
    7.     public static void main(String[] args) {
    8.         Thread t1 = new Thread(() -> {
    9.             synchronized (lock) {
    10.                 while (!t2runned) {
    11.                     try {
    12.                         lock.wait();
    13.                     } catch (InterruptedException e) {
    14.                         e.printStackTrace();
    15.                     }
    16.                 }
    17.                 log.debug("1");
    18.             }
    19.         }, "t1");
    20.  
    21.  
    22.         Thread t2 = new Thread(() -> {
    23.             synchronized (lock) {
    24.                 log.debug("2");
    25.                 t2runned = true;
    26.                 lock.notify();
    27.             }
    28.         }, "t2");
    29.  
    30.         t1.start();
    31.         t2.start();
    32.     }
    33. }

    1.2 Park Unpark 版 

    1. @Slf4j(topic = "c.Test26")
    2. public class Test26 {
    3.     public static void main(String[] args) {
    4.  
    5.         Thread t1 = new Thread(() -> {
    6.             LockSupport.park();
    7.             log.debug("1");
    8.         }, "t1");
    9.         t1.start();
    10.  
    11.         new Thread(() -> {
    12.             log.debug("2");
    13.             LockSupport.unpark(t1);
    14.         },"t2").start();
    15.     }
    16. }
    park 和 unpark 方法比较灵活，他俩谁先调用，谁后调用无所谓。并且是以线程为单位进行『暂停』和『恢复』， 不需要『同步对象』和『运行标记』

    2. 交替输出

    线程 1 输出 a 5 次，线程 2 输出 b 5 次，线程 3 输出 c 5 次。现在要求输出  abcabcabcabcabc 怎么实现

    2.1 wait notify 版 

    1. @Slf4j(topic = "c.Test27")
    2. public class Test27 {
    3.     public static void main(String[] args) {
    4.         WaitNotify wn = new WaitNotify(1, 5);
    5.         new Thread(() -> {
    6.             wn.print("a", 1, 2);
    7.         }).start();
    8.         new Thread(() -> {
    9.             wn.print("b", 2, 3);
    10.         }).start();
    11.         new Thread(() -> {
    12.             wn.print("c", 3, 1);
    13.         }).start();
    14.     }
    15. }
    16.  
    17. /*
    18. 输出内容       等待标记     下一个标记
    19.    a           1             2
    20.    b           2             3
    21.    c           3             1
    22.  */
    23. class WaitNotify {
    24.     // 打印               a           1             2
    25.     public void print(String str, int waitFlag, int nextFlag) {
    26.         for (int i = 0; i < loopNumber; i++) {
    27.             synchronized (this) {
    28.                 while(flag != waitFlag) {
    29.                     try {
    30.                         this.wait();
    31.                     } catch (InterruptedException e) {
    32.                         e.printStackTrace();
    33.                     }
    34.                 }
    35.                 System.out.print(str);
    36.                 flag = nextFlag;
    37.                 this.notifyAll();
    38.             }
    39.         }
    40.     }
    41.  
    42.     // 等待标记
    43.     private int flag; // 2
    44.     // 循环次数
    45.     private int loopNumber;
    46.  
    47.     public WaitNotify(int flag, int loopNumber) {
    48.         this.flag = flag;
    49.         this.loopNumber = loopNumber;
    50.     }
    51. }

    2.2 Lock 条件变量版

    1. public class Test30 {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         AwaitSignal awaitSignal = new AwaitSignal(5);
    4.         Condition a = awaitSignal.newCondition();
    5.         Condition b = awaitSignal.newCondition();
    6.         Condition c = awaitSignal.newCondition();
    7.         new Thread(() -> {
    8.             awaitSignal.print("a", a, b);
    9.         }).start();
    10.         new Thread(() -> {
    11.             awaitSignal.print("b", b, c);
    12.         }).start();
    13.         new Thread(() -> {
    14.             awaitSignal.print("c", c, a);
    15.         }).start();
    16.  
    17.         Thread.sleep(1000);
    18.         awaitSignal.lock();
    19.         try {
    20.             System.out.println("开始...");
    21.             a.signal();
    22.         } finally {
    23.             awaitSignal.unlock();
    24.         }
    25.  
    26.     }
    27. }
    28.  
    29. class AwaitSignal extends ReentrantLock{
    30.     private int loopNumber;
    31.  
    32.     public AwaitSignal(int loopNumber) {
    33.         this.loopNumber = loopNumber;
    34.     }
    35.     // 参数1 打印内容， 参数2 进入哪一间休息室, 参数3 下一间休息室
    36.     public void print(String str, Condition current, Condition next) {
    37.         for (int i = 0; i < loopNumber; i++) {
    38.             lock();
    39.             try {
    40.                 current.await();
    41.                 System.out.print(str);
    42.                 next.signal();
    43.             } catch (InterruptedException e) {
    44.                 e.printStackTrace();
    45.             } finally {
    46.                 unlock();
    47.             }
    48.         }
    49.     }
    50. }

    2.3 Park Unpark 版 

    1. @Slf4j(topic = "c.Test31")
    2. public class Test31 {
    3.  
    4.     static Thread t1;
    5.     static Thread t2;
    6.     static Thread t3;
    7.     public static void main(String[] args) {
    8.         ParkUnpark pu = new ParkUnpark(5);
    9.         t1 = new Thread(() -> {
    10.             pu.print("a", t2);
    11.         });
    12.         t2 = new Thread(() -> {
    13.             pu.print("b", t3);
    14.         });
    15.         t3 = new Thread(() -> {
    16.             pu.print("c", t1);
    17.         });
    18.         t1.start();
    19.         t2.start();
    20.         t3.start();
    21.  
    22.         LockSupport.unpark(t1);
    23.     }
    24. }
    25.  
    26. class ParkUnpark {
    27.     public void print(String str, Thread next) {
    28.         for (int i = 0; i < loopNumber; i++) {
    29.             LockSupport.park();
    30.             System.out.print(str);
    31.             LockSupport.unpark(next);
    32.         }
    33.     }
    34.  
    35.     private int loopNumber;
    36.  
    37.     public ParkUnpark(int loopNumber) {
    38.         this.loopNumber = loopNumber;
    39.     }
    40. }

  • 相关阅读:
    【python数据分析刷题】-N07.合并
    长沙理工大学开通CnOpenData试用
    python处理excel
    分类分析|KNN分类模型及其Python实现
    牛客前端宝典——刷题 ##Day10
    从新零售到社区团购，这中间发生了多少变化？
    C#与数据库连接
    cookie加密8
    浅谈一级机电管道设计中的压力与介质温度
    【ARXML专题】-26-Bit Rate相关参数：Tq，SJW，Sample Point，TDC...的定义
  • 原文地址：https://blog.csdn.net/yirenyuan/article/details/128156391