• JUC并发工具类在大厂的应用场景详解

            jdk提供了比synchronized更加高级的各种同步工具，包括 ReentrantLock 、 Semaphore 、 CountDownLatch 、 CyclicBarrier等，可以实现更加丰富的多线程操作。
    (前三个是重点)

            一. ReentrantLock

            ReentrantLock是一种可重入的独占锁，它允许同一个线程多次获取同一个锁而不会被阻塞。 它的功能类似于synchronized是一种互斥锁，可以保证线程安全。相对于 synchronized， ReentrantLock具备如下特点：

            1.1 可中断

            1.2 可以设置超时时间

            1.3 可以设置为公平锁（默认非公平锁）
            1.4 支持多个条件变量
            1.5 与 synchronized 一样，都支持可重入
    它的主要应用场景是 在多线程环境下对共享资源进行独占式访问，以保证数据的一致性和安全性。
            常用API
    void lock()
    获取锁，调用该方法当前线程会获取锁，当锁获
    得后，该方法返回
    void lockInterruptibly()
    可中断的获取锁，和lock()方法不同之处在于该方
    法会响应中断，即在锁的获取中可以中断当前线
    程
    boolean tryLock()
    尝试非阻塞的获取锁，调用该方法后立即返回。
    如果能够获取到返回true，否则返回false
    boolean tryLock(long time, TimeUnit unit)
    超时获取锁，当前线程在以下三种情况下会被返
    回:
    当前线程在超时时间内获取了锁
    当前线程在超时时间内被中断
    超时时间结束，返回false
    void unlock()
    		释放锁
    Condition newCondition()
    获取等待通知组件，该组件和当前的锁绑定，当 前线程只有获取了锁，才能调用该组件的await() 方法，而调用后，当前线程将释放锁

    注意点：   

            1. 默认情况下 ReentrantLock 为非公平锁而非公平锁;
            2. 加锁次数和释放锁次数一定要保持一致，否则会导致线程阻塞或程序异常;
            3. 加锁操作一定要放在 try 代码之前，这样可以避免未加锁成功又释放锁的异常;
            4. 释放锁一定要放在 finally 中，否则会导致线程阻塞。

            1.1 ReentrantLock使用

            独占锁：模拟抢票场景 

    1. package com.laoyang.Thread;
    2.  
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. /**
    6.  * @author:Kevin
    7.  * @create: 2023-10-11 18:17
    8.  * @Description: 模拟抢票
    9.  */
    10.  
    11. public class ReentrantLockDemo {
    12.     private final ReentrantLock lock = new ReentrantLock();//默认非公平
    13.     private static int tickets = 8; // 总票数
    14.  
    15.     public void buyTicket() {
    16.         lock.lock(); // 获取锁
    17.         try {
    18.             if (tickets > 0) { // 还有票
    19.                 try {
    20.                     Thread.sleep(10); // 休眠10ms,模拟出并发效果
    21.                 } catch (InterruptedException e) {
    22.                     e.printStackTrace();
    23.                 }
    24.                 System.out.println(Thread.currentThread().getName() + "购买了第" +
    25.                         tickets-- + "张票");
    26.             } else {
    27.                 System.out.println("票已经卖完了，" + Thread.currentThread().getName() +
    28.                         "抢票失败");
    29.             }
    30.  
    31.         } finally {
    32.             lock.unlock(); // 释放锁
    33.         }
    34.     }
    35.  
    36.  
    37.     public static void main(String[] args) {
    38.         ReentrantLockDemo ticketSystem = new ReentrantLockDemo();
    39.         for (int i = 1; i <= 10; i++) {
    40.             Thread thread = new Thread(() -> {
    41.  
    42.                 ticketSystem.buyTicket(); // 抢票
    43.  
    44.             }, "线程" + i);
    45.             // 启动线程
    46.             thread.start();
    47.  
    48.         }
    49.  
    50.  
    51.         try {
    52.             Thread.sleep(3000);
    53.         } catch (InterruptedException e) {
    54.             throw new RuntimeException(e);
    55.         }
    56.         System.out.println("剩余票数：" + tickets);
    57.     }
    58. }

            

           1.2 公平锁和非公平锁

            ReentrantLock支持公平锁和非公平锁两种模式：

            公平锁：线程在获取锁时，按照等待的先后顺序获取锁。

            非公平锁：线程在获取锁时，不按照等待的先后顺序获取锁，而是随机获取锁。ReentrantLock默认是非公平锁
            比如买票的时候就有可能出现插队的场景，允许插队就是非公平锁，如下图：

            1.3 结合Condition实现生产者消费者模式

    java.util.concurrent类库中提供Condition类来实现线程之间的协调。调用Condition.await() 方法使
    线程等待，其他线程调用Condition.signal() 或 Condition.signalAll() 方法唤醒等待的线程。
    注意： 调用Condition的await()和signal()方法，都必须在lock保护之内。
    案例：基于ReentrantLock和Condition实现一个简单队列 
    1. package com.laoyang.Thread;
    2.  
    3.  
    4. import java.util.Random;
    5. import java.util.concurrent.locks.Condition;
    6. import java.util.concurrent.locks.ReentrantLock;
    7.  
    8. /**
    9.  * @author:Kevin
    10.  * @create: 2023-10-11 18:29
    11.  * @Description: 模拟生产消费场景
    12.  */
    13.  
    14. public class ReentrantLockDemo3 {
    15.  
    16.     public static void main(String[] args) {
    17.         // 创建队列
    18.         Queue queue = new Queue(5);
    19.         //启动生产者线程
    20.         new Thread(new Producer(queue)).start();
    21.         //启动消费者线程
    22.         new Thread(new Customer(queue)).start();
    23.     }
    24.  
    25.     public static class Queue {
    26.         private Object[] items;
    27.         int size = 0;
    28.         int takeIndex;
    29.         int putIndex;
    30.         private ReentrantLock lock;
    31.         public Condition notEmpty; //消费者线程阻塞唤醒条件，队列为空阻塞，生产者生产完唤醒
    32.         public Condition notFull; //生产者线程阻塞唤醒条件，队列满了阻塞，消费者消费完唤醒
    33.  
    34.         public Queue(int capacity) {
    35.             this.items = new Object[capacity];
    36.             lock = new ReentrantLock();
    37.             notEmpty = lock.newCondition();
    38.             notFull = lock.newCondition();
    39.         }
    40.  
    41.  
    42.         public void put(Object value) throws Exception {
    43.             //加锁
    44.             lock.lock();
    45.             try {
    46.                 while (size == items.length)
    47.                     // 队列满了让生产者等待
    48.                     notFull.await();
    49.  
    50.                 items[putIndex] = value;
    51.                 if (++putIndex == items.length)
    52.                     putIndex = 0;
    53.                 size++;
    54.                 notEmpty.signal(); // 生产完唤醒消费者
    55.  
    56.             } finally {
    57.                 System.out.println("producer生产：" + value);
    58.                 //解锁
    59.                 lock.unlock();
    60.             }
    61.         }
    62.  
    63.         public Object take() throws Exception {
    64.             lock.lock();
    65.             try {
    66.                 // 队列空了就让消费者等待
    67.                 while (size == 0)
    68.                     notEmpty.await();
    69.  
    70.                 Object value = items[takeIndex];
    71.                 items[takeIndex] = null;
    72.                 if (++takeIndex == items.length)
    73.                     takeIndex = 0;
    74.                 size--;
    75.                 notFull.signal(); //消费完唤醒生产者生产
    76.                 return value;
    77.             } finally {
    78.                 lock.unlock();
    79.             }
    80.         }
    81.     }
    82.  
    83.     static class Producer implements Runnable {
    84.  
    85.         private Queue queue;
    86.  
    87.         public Producer(Queue queue) {
    88.             this.queue = queue;
    89.         }
    90.  
    91.         @Override
    92.         public void run() {
    93.             try {
    94.                 // 隔1秒轮询生产一次
    95.                 while (true) {
    96.                     Thread.sleep(1000);
    97.                     queue.put(new Random().nextInt(1000));
    98.                 }
    99.             } catch (Exception e) {
    100.                 e.printStackTrace();
    101.             }
    102.         }
    103.     }
    104.  
    105.     /**
    106.      * 101 * 消费者
    107.      * 102
    108.      */
    109.     static class Customer implements Runnable {
    110.  
    111.         private Queue queue;
    112.  
    113.         public Customer(Queue queue) {
    114.             this.queue = queue;
    115.         }
    116.  
    117.         @Override
    118.         public void run() {
    119.             try {
    120.                 // 隔2秒轮询消费一次
    121.                 while (true) {
    122.                     Thread.sleep(2000);
    123.                     System.out.println("consumer消费：" + queue.take());
    124.                 }
    125.             } catch (Exception e) {
    126.                 e.printStackTrace();
    127.             }
    128.         }
    129.     }
    130.  
    131.  
    132. }
    1.3 应用场景总结
            
    ReentrantLock具体应用场景如下：
            1. 解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次
    只有一个线程能够写入。
            2. 实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。
            3. 实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。

            二. Semaphore 

            Semaphore（信号量）是一种用于多线程编程的同步工具，用于控制同时访问某个资源的线程数量。

            Semaphore维护了一个计数器，线程可以通过调用acquire()方法来获取Semaphore中的许可证，当计数器为0时，调用acquire()的线程将被阻塞，直到有其他线程释放许可证；线程可以通过调用release()方法来释放Semaphore中的许可证，这会使Semaphore中的计数器增加，从而允许更多的线程访问共享资源。

    2.1 常用方法

    acquire()表示阻塞并获取许可
    tryAcquire()方法在没有许可的情况下会立即返回 false，要获取许可的线程不会阻塞
    release()表示释放许可

    2.2 Semaphore实现服务接口限流

    1. package com.laoyang.Thread;
    2.  
    3. import java.util.concurrent.Executor;
    4. import java.util.concurrent.Executors;
    5. import java.util.concurrent.Semaphore;
    6.  
    7. /**
    8.  * @author:Kevin
    9.  * @create: 2023-10-11 18:48
    10.  * @Description: 模拟限流操作
    11.  */
    12.  
    13. public class SemaphoreDemo {
    14.  
    15.     //信号量
    16.     private static Semaphore semaphore = new Semaphore(2);
    17.  
    18.     private static Executor executor = Executors.newFixedThreadPool(10);
    19.  
    20.  
    21.     public static void main(String[] args) {
    22.         for(int i=0;i<10;i++){
    23.              executor.execute(()->getProductInfo2());
    24.         }
    25.     }
    26.  
    27.     public static String getProductInfo2() {
    28.  
    29.          if(!semaphore.tryAcquire()){
    30.              System.out.println("请求被流控了");
    31.              return "请求被流控了";
    32.              }
    33.          try {
    34.              System.out.println("请求服务");
    35.              Thread.sleep(2000);
    36.              } catch (InterruptedException e) {
    37.              throw new RuntimeException(e);
    38.              }finally {
    39.              semaphore.release();
    40.              }
    41.          return "返回商品详情信息";
    42.          }
    43. }

    2.3 应用场景总结

            以下是一些使用Semaphore的常见场景：
            1. 限流：Semaphore可以用于限制对共享资源的并发访问数量，以控制系统的流量。
            2. 资源池：Semaphore可以用于实现资源池，以维护一组有限的共享资源。

            

            三. CountDownLatch 

            CountDownLatch（闭锁）是一个同步协助类，允许一个或多个线程等待，直到其他线程完成操作集。

            CountDownLatch使用给定的计数值（count）初始化。await方法会阻塞直到当前的计数值 （count），由于countDown方法的调用达到0，count为0之后所有等待的线程都会被释放，并且随后对await方法的调用都会立即返回。这是一个一次性现象 —— count不会被重置。

            3.1 常用方法

    void await ()
    调用 await() 方法的线程会被挂起，它会等待直到 count 值为 0 才继续执行
    boolean await ( long timeout , TimeUnit unit )
    和 await() 类似，若等待 timeout 时长后， count 值还是没有变为 0 ，不再等待，继续执行
    void countDown ()
    会将 count 减 1 ，直至为 0

            3.2 CountDownLatch使用

            模拟实现百米赛跑

    1. package com.laoyang.Thread;
    2.  
    3. import java.util.concurrent.CountDownLatch;
    4.  
    5. /**
    6.  * @author:Kevin
    7.  * @create: 2023-10-11 18:59
    8.  * @Description: 模拟实现百米赛跑
    9.  */
    10.  
    11. public class CountDownLatchDemo {
    12.  
    13.     // begin 代表裁判 初始为 1
    14.     private static CountDownLatch begin = new CountDownLatch(1);
    15.  
    16.     // end 代表玩家 初始为 8
    17.     private static CountDownLatch end = new CountDownLatch(8);
    18.  
    19.  
    20.     public static void main(String[] args) throws InterruptedException {
    21.         for (int i = 1; i <= 8; i++) {
    22.              new Thread(new Runnable() {
    23.                 @Override
    24.                 public void run() {
    25.                     // 预备状态
    26.                     System.out.println("参赛者" + Thread.currentThread().getName() + "已经准备好了");
    27.                     // 等待裁判吹哨
    28.                     try {
    29.                         begin.await();
    30.                     } catch (InterruptedException e) {
    31.                         throw new RuntimeException(e);
    32.                     }
    33.                     // 开始跑步
    34.                     System.out.println("参赛者" + Thread.currentThread().getName() + "开始跑步");
    35.                     try {
    36.                         Thread.sleep(1000);
    37.                     } catch (InterruptedException e) {
    38.                         throw new RuntimeException(e);
    39.                     }
    40.                     // 跑步结束, 跑完了
    41.                     System.out.println("参赛者" + Thread.currentThread().getName() + "到达终点");
    42.                             // 跑到终点, 计数器就减一
    43.                             end.countDown();
    44.                 }
    45.             }).start();
    46.         }
    47.         // 等待 5s 就开始吹哨
    48.         Thread.sleep(5000);
    49.         System.out.println("开始比赛");
    50.         // 裁判吹哨, 计数器减一
    51.         begin.countDown();
    52.         // 等待所有玩家到达终点
    53.         end.await();
    54.         System.out.println("比赛结束");
    55.     }
    56. }

            多任务完成后合并汇总

            很多时候，我们的并发任务，存在前后依赖关系；比如数据详情页需要同时调用多个接口获取数据，并发请求获取到数据后、需要进行结果合并；或者多个数据操作完成后，需要数据check。 

    1. package com.laoyang.Thread;
    2.  
    3. import java.util.concurrent.CountDownLatch;
    4. import java.util.concurrent.ThreadLocalRandom;
    5.  
    6. /**
    7.  * @author:Kevin
    8.  * @create: 2023-10-11 19:10
    9.  * @Description: 多任务完成后合并汇总
    10.  */
    11.  
    12. public class CountDownLatchDemo2 {
    13.  
    14.     public static void main(String[] args) throws Exception {
    15.         CountDownLatch countDownLatch = new CountDownLatch(5);
    16.         for (int i = 0; i < 5; i++) {
    17.             final int index = i;
    18.             new Thread(() -> {
    19.                 try {
    20.                     Thread.sleep(1000 + ThreadLocalRandom.current().nextInt(2000));
    21.                     System.out.println("任务" + index + "执行完成");
    22.                     countDownLatch.countDown();
    23.                 } catch (InterruptedException e) {
    24.                     e.printStackTrace();
    25.                 }
    26.             }).start();
    27.         }
    28.  
    29.         // 主线程在阻塞，当计数器为0，就唤醒主线程往下执行
    30.         countDownLatch.await();
    31.         System.out.println("主线程:在所有任务运行完成后，进行结果汇总");
    32.  
    33.     }
    34. }

    3.3 应用场景总结

    以下是使用CountDownLatch的常见场景：
             1. 并行任务同步：CountDownLatch可以用于协调多个并行任务的完成情况，确保所有任务都完成后再继续执行下
    一步操作。
            2. 多任务汇总：CountDownLatch可以用于统计多个线程的完成情况，以确定所有线程都已完成工作。
            3. 资源初始化：CountDownLatch可以用于等待资源的初始化完成，以便在资源初始化完成后开始使用。

              四. CyclicBarrier

            CyclicBarrier（回环栅栏或循环屏障），是 Java 并发库中的一个同步工具，通过它可以实现让一组线程等待至某个状态（屏障点）之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。

            4.1 常用方法

    int await ()
    指定数量的线程全部调用 await() 方法时，这些线程不再阻塞
    int await ( long timeout , TimeUnit unit )
    BrokenBarrierException 表示栅栏已经被破坏，破坏的原因可能是其中一个线程 await() 时被中断
    或者超时
    void reset ()
    循环 通过 reset() 方法可以进行重置

            4.2 CyclicBarrier使用

            利用CyclicBarrier的计数器能够重置，屏障可以重复使用的特性，可以支持类似“人满发车”的场景

    1. package com.laoyang.Thread;
    2.  
    3. import java.util.concurrent.*;
    4.  
    5. /**
    6.  * @author:Kevin
    7.  * @create: 2023-10-11 19:20
    8.  * @Description:模拟人满发车
    9.  */
    10.  
    11. public class CyclicBarrierDemo {
    12.     public static void main(String[] args) {
    13.  
    14.         ExecutorService executorService = Executors.newFixedThreadPool(5);
    15.         
    16.         CyclicBarrier cyclicBarrier = new CyclicBarrier(5,
    17.                 () -> System.out.println("人齐了，准备发车"));
    18.  
    19.         for (int i = 0; i < 10; i++) {
    20.             final int id = i + 1;
    21.             executorService.submit(new Runnable() {
    22.                 @Override
    23.                 public void run() {
    24.                     try {
    25.                         System.out.println(id + "号马上就到");
    26.                         int sleepMills = ThreadLocalRandom.current().nextInt(2000);
    27.                         Thread.sleep(sleepMills);
    28.                         System.out.println(id + "号到了，上车");
    29.                         cyclicBarrier.await();
    30.  
    31.                     } catch (InterruptedException e) {
    32.                         e.printStackTrace();
    33.                     } catch (BrokenBarrierException e) {
    34.                         e.printStackTrace();
    35.                     }
    36.                 }
    37.             });
    38.         }
    39.     }
    40. }

    4.3 应用场景总结

    以下是一些常见的 CyclicBarrier 应用场景：
            1. 多线程任务：CyclicBarrier 可以用于将复杂的任务分配给多个线程执行，并在所有线程完成工作后触发后续操
    作。
            2. 数据处理：CyclicBarrier 可以用于协调多个线程间的数据处理，在所有线程处理完数据后触发后续操作。

    4.4 CyclicBarrier 与 CountDownLatch 区别

            1. CountDownLatch 是一次性的，CyclicBarrier 是可循环利用的
            2. CountDownLatch 参与的线程的职责是不一样的，有的在倒计时，有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。

            五. Exchanger 

            Exchanger是一个用于线程间协作的工具类，用于两个线程间交换数据。具体交换数据是通过exchange方法来实现的，如果一个线程先执行exchange方法，那么它会同步等待另一个线程也执行 exchange方法，这个时候两个线程就都达到了同步点，两个线程就可以交换数据。

            5.1 Exchanger使用

            模拟交易场景

    用一个简单的例子来看下Exchanger的具体使用。两方做交易，如果一方先到要等另一方也到了才能交易，交易就是执行exchange方法交换数据。 
    1. package com.laoyang.Thread;
    2.  
    3. import java.util.concurrent.Exchanger;
    4.  
    5. /**
    6.  * @author:Kevin
    7.  * @create: 2023-10-11 19:25
    8.  * @Description: 模拟交换
    9.  */
    10.  
    11. public class ExchangerDemo {
    12.     private static Exchanger exchanger = new Exchanger();
    13.     static String goods = "电脑";
    14.     static String money = "$4000";
    15.  
    16.     public static void main(String[] args) throws InterruptedException {
    17.         System.out.println("准备交易，一手交钱一手交货...");
    18.         // 卖家
    19.         new Thread(new Runnable() {
    20.             @Override
    21.             public void run() {
    22.                 System.out.println("卖家到了，已经准备好货：" + goods);
    23.                 try {
    24.                     String money = (String) exchanger.exchange(goods);
    25.                     System.out.println("卖家收到钱：" + money);
    26.                 } catch (Exception e) {
    27.                     e.printStackTrace();
    28.                 }
    29.             }
    30.         }).start();
    31.  
    32.         Thread.sleep(3000);
    33.  
    34.         // 买家
    35.         new Thread(new Runnable() {
    36.             @Override
    37.             public void run() {
    38.                 try {
    39.                     System.out.println("买家到了，已经准备好钱：" + money);
    40.                     String goods = (String) exchanger.exchange(money);
    41.                     System.out.println("买家收到货：" + goods);
    42.                 } catch (Exception e) {
    43.                     e.printStackTrace();
    44.                 }
    45.             }
    46.         }).start();
    47.  
    48.     }
    49. }

            5.2 应用场景总结

            Exchanger 可以用于各种应用场景，具体取决于具体的 Exchanger 实现。常见的场景包括：

            1. 数据交换：在多线程环境中，两个线程可以通过 Exchanger 进行数据交换。

            2. 数据采集：在数据采集系统中，可以使用 Exchanger 在采集线程和处理线程间进行数据交换。

            六. Phaser  

            Phaser（阶段协同器）是一个Java实现的并发工具类，用于协调多个线程的执行。它提供了一些方便的方法来管理多个阶段的执行，可以让程序员灵活地控制线程的执行顺序和阶段性的执行。Phaser可以被视为CyclicBarrier和CountDownLatch的进化版，它能够自适应地调整并发线程数，可以动态地增加或减少参与线程的数量。所以Phaser特别适合使用在重复执行或者重用的情况。

  • 相关阅读:
    网络工程师入门必懂华为认证体系，附系统学习路线分享
    第二章 Scala变量和数据类型
    上传本地包到私有maven仓库
    朴素贝叶斯法
    Linux 大页内存 Huge Pages 虚拟内存
    C 语言程序的执行流程
    cocoeval 解析
    Canvas 低代码工具，多人自研开发全流程优化｜ModelWhale 版本更新
    蓝桥杯真题：纯质数
    Meter接口测试使用教程哪里找？
  • 原文地址：https://blog.csdn.net/qq_67801847/article/details/133775775