• ReentrantLock实现公平锁，可中断，条件变量，可重入案例

    1.ReentrantLock实现公平锁

    1. /**
    2.  * ReentrantLock实现公平锁
    3.  * 创建了三个线程，依次打印线程
    4.  */
    5. public class FairLockExample {
    6.     private static ReentrantLock fairLock = new ReentrantLock(true); // 创建公平锁
    7.  
    8.     public static void main(String[] args) {
    9.         Runnable fairTask = new FairTask();
    10.  
    11.         // 创建多个线程来竞争公平锁
    12.         Thread thread1 = new Thread(fairTask, "Thread-1");
    13.         Thread thread2 = new Thread(fairTask, "Thread-2");
    14.         Thread thread3 = new Thread(fairTask, "Thread-3");
    15.  
    16.         thread1.start();
    17.         thread2.start();
    18.         thread3.start();
    19.     }
    20.  
    21.     static class FairTask implements Runnable {
    22.         @Override
    23.         public void run() {
    24.             while (true) {
    25.                 try {
    26.                     fairLock.lock();
    27.                     System.out.println(Thread.currentThread().getName() + " 获取到锁");
    28.                     Thread.sleep(1000);
    29.                 } catch (InterruptedException e) {
    30.                     e.printStackTrace();
    31.                 } finally {
    32.                     fairLock.unlock();
    33.                     System.out.println(Thread.currentThread().getName() + " 释放锁");
    34.                 }
    35.             }
    36.         }
    37.     }
    38. }

    输出结果

    1. Thread-1 获取到锁
    2. Thread-1 释放锁
    3. Thread-2 获取到锁
    4. Thread-2 释放锁
    5. Thread-3 获取到锁
    6. Thread-3 释放锁
    7. Thread-1 获取到锁
    8. Thread-1 释放锁
    9. Thread-2 获取到锁
    10. Thread-2 释放锁
    11. Thread-3 获取到锁
    12. Thread-3 释放锁
    13. Thread-1 获取到锁
    14. Thread-1 释放锁
    15. Thread-2 获取到锁
    16. Thread-2 释放锁
    17. Thread-3 获取到锁

    2.ReentrantLock实现可中断锁

    1. /**
    2.  * 演示ReentrantLock调用lockInterruptibly方法可以被中断
    3.  * https://blog.csdn.net/ZSA222/article/details/123433746?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522170022637516800182740333%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=170022637516800182740333&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-123433746-null-null.142^v96^pc_search_result_base5&utm_term=ReentrantLock&spm=1018.2226.3001.4187
    4.  */
    5. public class ReentrantLockInterrupt {
    6.     private static ReentrantLock lock = new ReentrantLock();
    7.  
    8.     public static void main(String[] args) throws InterruptedException {
    9.         Thread thread = new Thread(() -> {
    10.             try {
    11.                 // 如果没有竞争那么此方法就会获取 lock 对象锁
    12.                 // 如果有竞争就进入阻塞队列，可以被其它线程用 interruput 方法打断
    13.                 System.out.println(Thread.currentThread().getName() +  LocalDateTime.now() + "尝试获得锁");
    14.                 Thread.sleep(15000);
    15.                 lock.lockInterruptibly();
    16.             } catch (InterruptedException e) {
    17.                 e.printStackTrace();
    18.                 System.out.println(Thread.currentThread().getName() + LocalDateTime.now() + "t1线程没有获得锁，被打断...return");
    19.                 return;
    20.             }
    21.             try {
    22.                 System.out.println(Thread.currentThread().getName() + LocalDateTime.now() + "t1线程获得了锁");
    23.             } finally {
    24.                 lock.unlock();
    25.             }
    26.         }, "t1");
    27.  
    28.         // t1启动前 主线程先获得了锁
    29.         lock.lock();
    30.         thread.start(); // thread线程会进入阻塞队列
    31.         Thread.sleep(5000);
    32.         System.out.println(Thread.currentThread().getName() + LocalDateTime.now() + "interrupt...打断t1");
    33.         Thread.sleep(2000);
    34.         thread.interrupt();
    35.     }
    36. }

    输出结果

    1. t111:27:23尝试获得锁
    2. main11:27:28interrupt...打断t1
    3. java.lang.InterruptedException: sleep interrupted
    4. 	at java.lang.Thread.sleep(Native Method)
    5. 	at concurrentpro.lock.ReentrantLockInterrupt.lambda$main$0(ReentrantLockInterrupt.java:20)
    6. 	at java.lang.Thread.run(Thread.java:750)
    7. t111:27:30t1线程没有获得锁，被打断...return
    1. /**
    2.  * 演示ReentrantLock调用普通lock方法，不能被中断
    3.  * https://blog.csdn.net/ZSA222/article/details/123433746?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522170022637516800182740333%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=170022637516800182740333&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-123433746-null-null.142^v96^pc_search_result_base5&utm_term=ReentrantLock&spm=1018.2226.3001.4187
    4.  */
    5. public class ReentrantLock {
    6.     private static java.util.concurrent.locks.ReentrantLock lock = new java.util.concurrent.locks.ReentrantLock();
    7.  
    8.     public static void main(String[] args) throws InterruptedException {
    9.  
    10.         Thread thread = new Thread(() -> {
    11.             System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("hh:mm:ss")) + Thread.currentThread().getName() + "尝试获得锁");
    12.             lock.lock();
    13.             try {
    14.                 System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("hh:mm:ss")) + Thread.currentThread().getName() + "t1线程获得了锁");
    15.             } finally {
    16.                 lock.unlock();
    17.             }
    18.         }, "t1");
    19.  
    20.         // t1启动前 主线程先获得了锁
    21.         lock.lock();
    22.         thread.start();
    23.         Thread.sleep(1000);
    24.         System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("hh:mm:ss")) + Thread.currentThread().getName() + "interrupt...打断t1");
    25.         thread.interrupt();
    26.     }
    27. }

    输出结果 

    1. 11:24:39t1尝试获得锁
    2. 11:24:40maininterrupt...打断t1

    3.ReentrantLock实现条件变量

    1.  
    2. /**
    3.  * ReentrantLock 之 condtion的用法
    4.  * 配合 condition.await 和 condition.signal
    5.  * 来源：bilibli 黑马程序员之并发编程
    6.  */
    7. public class ConditionVariable {
    8.     private static boolean hasCigarette = false;
    9.     private static boolean hasTakeout = false;
    10.     private static final ReentrantLock lock = new ReentrantLock();
    11.  
    12.     // 等待烟的休息室（条件变量）
    13.     static Condition waitCigaretteSet = lock.newCondition();
    14.     // 等外卖的休息室（条件变量）
    15.     static Condition waitTakeoutSet = lock.newCondition();
    16.  
    17.     public static void main(String[] args) throws InterruptedException {
    18.  
    19.         new Thread(() -> {
    20.             lock.lock();
    21.             try {
    22.                 System.out.println(LocalTime.now() +  Thread.currentThread().getName() + "有烟没？[{}]" + hasCigarette);
    23.                 while (!hasCigarette) {
    24.                     System.out.println(LocalTime.now() +   Thread.currentThread().getName()  +"没烟，先歇会！");
    25.                     try {
    26.                         // 此时小南进入到 等烟的休息室
    27.                         waitCigaretteSet.await();
    28.                     } catch (InterruptedException e) {
    29.                         e.printStackTrace();
    30.                     }
    31.                 }
    32.                 System.out.println(LocalTime.now() +  Thread.currentThread().getName()  + "烟来咯, 可以开始干活了");
    33.             } finally {
    34.                 lock.unlock();
    35.             }
    36.         }, "小南").start();
    37.  
    38.         new Thread(() -> {
    39.             lock.lock();
    40.             try {
    41.                 System.out.println(LocalTime.now() +  Thread.currentThread().getName()  +"外卖送到没？[{}]" + hasTakeout);
    42.                 while (!hasTakeout) {
    43.                     System.out.println(LocalTime.now() +  Thread.currentThread().getName()  + "没外卖，先歇会！");
    44.                     try {
    45.                         // 此时小女进入到 等外卖的休息室
    46.                         waitTakeoutSet.await();
    47.                     } catch (InterruptedException e) {
    48.                         e.printStackTrace();
    49.                     }
    50.                 }
    51.                 System.out.println(LocalTime.now() +   Thread.currentThread().getName()  +"外卖来咯, 可以开始干活了");
    52.             } finally {
    53.                 lock.unlock();
    54.             }
    55.         }, "小女").start();
    56.  
    57.         Thread.sleep(1000);
    58.         new Thread(() -> {
    59.             lock.lock();
    60.             try {
    61.                 System.out.println(LocalTime.now() +  Thread.currentThread().getName()  + "送外卖的来咯~");
    62.                 hasTakeout = true;
    63.                 // 唤醒等外卖的小女线程
    64.                 waitTakeoutSet.signal();
    65.             } finally {
    66.                 lock.unlock();
    67.             }
    68.         }, "送外卖的").start();
    69.  
    70.         Thread.sleep(1000);
    71.         new Thread(() -> {
    72.             lock.lock();
    73.             try {
    74.                 System.out.println(LocalTime.now() +  Thread.currentThread().getName()  +"送烟的来咯~");
    75.                 hasCigarette = true;
    76.                 // 唤醒等烟的小南线程
    77.                 waitCigaretteSet.signal();
    78.             } finally {
    79.                 lock.unlock();
    80.             }
    81.         }, "送烟的").start();
    82.     }
    83. }

    输出结果

    1. 11:29:38.644小南有烟没？[{}]false
    2. 11:29:38.645小南没烟，先歇会！
    3. 11:29:38.645小女外卖送到没？[{}]false
    4. 11:29:38.645小女没外卖，先歇会！
    5. 11:29:39.620送外卖的送外卖的来咯~
    6. 11:29:39.620小女外卖来咯, 可以开始干活了
    7. 11:29:40.621送烟的送烟的来咯~
    8. 11:29:40.621小南烟来咯, 可以开始干活了

    4.ReentrantLock实现可重入

    1. public class ReentrantLockExample {
    2.     private ReentrantLock lock = new ReentrantLock();
    3.  
    4.     public void performTask() {
    5.         lock.lock();
    6.         try {
    7.             System.out.println("Task started");
    8.             // 可以多次获取锁
    9.             lock.lock();
    10.             try {
    11.                 System.out.println("Task is performing");
    12.             } finally {
    13.                 lock.unlock();
    14.                 System.out.println("Inner lock released");
    15.             }
    16.             System.out.println("Task completed");
    17.         } finally {
    18.             lock.unlock();
    19.             System.out.println("Outer lock released");
    20.         }
    21.     }
    22.  
    23.     public static void main(String[] args) {
    24.         ReentrantLockExample example = new ReentrantLockExample();
    25.         example.performTask();
    26.     }
    27. }

    输出结果

    1. Task started
    2. Task is performing
    3. Inner lock released
    4. Task completed
    5. Outer lock released

  • 相关阅读:
    Java中的LinkedHashSet使用[71]
    JavaScript继承的几种方式
    【每天学习一点新知识】网络安全--拒绝服务攻击
    PEG功能化/修饰/偶联中空二氧化硅纳米球 PEG-Hollow SiO2 nanosphere
    【Java】Servlet API
    【GAN入门】生成 AI的概念
    第7章 SpringMVC
    navicat连接postgresql报错解决方案
    220V转18V非隔离降压芯片：满足多种应用需求
    c++图片取出每一个像素的值
  • 原文地址：https://blog.csdn.net/xuan__xia/article/details/134475948