• 自己写并发工具是一种什么体验？

    首先给大家介绍三个工具Semaphore, CyclicBarrier, CountDownLatch该如何使用，然后仔细剖析这三个工具内部实现的原理，最后会跟大家一起用ReentrantLock实现这三个工具。希望对大家有帮助，喜欢的点赞收藏哦~

    并发工具类的使用

    CountDownLatch

    CountDownLatch最主要的作用是允许一个或多个线程等待其他线程完成操作。比如我们现在有一个任务，有N个线程会往数组data[N]当中对应的位置根据不同的任务放入数据，在各个线程将数据放入之后，主线程需要将这个数组当中所有的数据进行求和计算，也就是说主线程在各个线程放入之前需要阻塞住！在这样的场景下，我们就可以使用CountDownLatch。

    上面问题的代码：

    1. import java.util.Arrays;
    2. import java.util.Random;
    3. import java.util.concurrent.CountDownLatch;
    4.  
    5. public class CountDownLatchDemo {
    6.  
    7.     public static int[] data = new int[10];
    8.  
    9.     public static void main(String[] args) throws InterruptedException {
    10.         CountDownLatch latch = new CountDownLatch(10);
    11.  
    12.         for (int i = 0; i < 10; i++) {
    13.             int temp = i;
    14.             new Thread(() -> {
    15.                 Random random = new Random();
    16.                 data[temp] = random.nextInt(100001);
    17.                 latch.countDown();
    18.             }).start();
    19.         }
    20.  
    21.         // 只有函数 latch.countDown() 至少被调用10次
    22.         // 主线程才不会被阻塞
    23.         // 这个10是在CountDownLatch初始化传递的10
    24.         latch.await();
    25.         System.out.println("求和结果为：" + Arrays.stream(data).sum());
    26.     }
    27. }

    在上面的代码当中，主线程通过调用latch.await();将自己阻塞住，然后需要等他其他线程调用方法latch.countDown()只有这个方法被调用的次数等于在初始化时给CountDownLatch传递的参数时，主线程才会被释放。

    CyclicBarrier

    CyclicBarrier它要做的事情是，让一 组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。我们通常也将CyclicBarrier称作路障。

    示例代码：

    1. public class CycleBarrierDemo {
    2.  
    3.     public static void main(String[] args) {
    4.         CyclicBarrier barrier = new CyclicBarrier(5);
    5.  
    6.         for (int i = 0; i < 5; i++) {
    7.             new Thread(() -> {
    8.                 try {
    9.                     System.out.println(Thread.currentThread().getName() + "开始等待");
    10.                     // 所有线程都会调用这行代码
    11.                     // 在这行代码调用的线程个数不足5
    12.                     // 个的时候所有的线程都会阻塞在这里
    13.                     // 只有到5的时候，这5个线程才会被放行
    14.                     // 所以这行代码叫做同步点 
    15.                     barrier.await();
    16.                     // 如果有第六个线程执行这行代码时
    17.                     // 第六个线程也会被阻塞 知道第10
    18.                     // 线程执行这行代码 6-10 这5个线程
    19.                     // 才会被放行
    20.                 } catch (InterruptedException e) {
    21.                     e.printStackTrace();
    22.                 } catch (BrokenBarrierException e) {
    23.                     e.printStackTrace();
    24.                 }
    25.                 System.out.println(Thread.currentThread().getName() + "等待完成");
    26.             }).start();
    27.         }
    28.     }
    29. }

    我们在初始化CyclicBarrier对象时，传递的数字为5，这个数字表示只有5个线程到达同步点的时候，那5个线程才会同时被放行，而如果到了6个线程的话，第一次没有被放行的线程必须等到下一次有5个线程到达同步点barrier.await()时，才会放行5个线程。

    • 比如刚开始的时候5个线程的状态如下，同步点还没有5个线程到达，因此不会放行。

    • 当有5个线程或者更多的线程到达同步点barrier.await()的时候，才会放行5个线程，注意是5个线程，如果有多的线程必须等到下一次集合5个线程才会进行又一次放行，也就是说每次只放行5个线程，这也是它叫做CyclicBarrier（循环路障）的原因（因为每次放行5个线程，放行完之后重新计数，直到又有5个新的线程到来，才再次放行）。

    Semaphore

    Semaphore（信号量）通俗一点的来说就是控制能执行某一段代码的线程数量，他可以控制程序的并发量！

    semaphore.acquire
    R

    semaphore.release

    比如在上面的acquire和release之间的代码R就是我们需要控制的代码，我们可以通过信号量控制在某一个时刻能有多少个线程执行代码R。在信号量内部有一个计数器，在我们初始化的时候设置为N，当有线程调用acquire函数时，计数器需要减一，调用release函数时计数器需要加一，只有当计数器大于0时，线程调用acquire时才能够进入代码块R，否则会被阻塞，只有线程调用release函数时，被阻塞的线程才能被唤醒，被唤醒的时候计数器会减一。

    示例代码：

    1. import java.util.concurrent.Semaphore;
    2. import java.util.concurrent.TimeUnit;
    3.  
    4. public class SemaphoreDemo {
    5.     public static void main(String[] args) {
    6.         Semaphore mySemaphore = new Semaphore(5);
    7.         for (int i = 0; i < 10; i++) {
    8.             new Thread(() -> {
    9.                 System.out.println(Thread.currentThread().getName() + "准备进入临界区");
    10.                 try {
    11.                     mySemaphore.acquire();
    12.                 } catch (InterruptedException e) {
    13.                     e.printStackTrace();
    14.                 }
    15.                 System.out.println(Thread.currentThread().getName() + "已经进入临界区");
    16.                 try {
    17.                     TimeUnit.SECONDS.sleep(2);
    18.                 } catch (InterruptedException e) {
    19.                     e.printStackTrace();
    20.                 }
    21.                 System.out.println(Thread.currentThread().getName() + "准备离开临界区");
    22.                 mySemaphore.release();
    23.                 System.out.println(Thread.currentThread().getName() + "已经离开临界区");
    24.             }).start();
    25.         }
    26.     }
    27. }

    自己动手写并发工具类

    在这一小节当中主要使用ReentrantLock实现上面我们提到的三个并发工具类，因此你首先需要了解ReentrantLock这个工具。ReentrantLock中有两个主要的函数lock和unlock，主要用于临界区的保护，在同一个时刻只能有一个线程进入被lock和unlock包围的代码块。除此之外你还需要了解ReentrantLock.newCondition函数，这个函数会返回一个条件变量Condition，这个条件变量有三个主要的函数await、signal和signalAll，这三个函数的作用和效果跟Object类的wait、notify和notifyAll一样，在阅读下文之前，大家首先需要了解他们的用法。

    • 哪个线程调用函数condition.await，那个线程就会被挂起。
    • 如果线程调用函数conditon.signal，则会唤醒一个被condition.await函数阻塞的线程。
    • 如果线程调用函数conditon.signalAll，则会唤醒所有被condition.await函数阻塞的线程。

    CountDownLatch

    我们在使用CountDownLatch时，会有线程调用CountDownLatch的await函数，其他线程会调用CountDownLatch的countDown函数。在CountDownLatch内部会有一个计数器，计数器的值我们在初始化的时候可以进行设置，线程每调用一次countDown函数计数器的值就会减一。

    • 如果在线程在调用await函数之前，计数器的值已经小于或等于0时，调用await函数的线程就不会阻塞，直接放行。
    • 如果在线程在调用await函数之前，计数器的值大于0时，调用await函数的线程就会被阻塞，当有其他线程将计数器的值降低为0时，那么这个将计数器降低为0线程就需要使用condition.signalAll()函数将其他所有被await阻塞的函数唤醒。
    • 线程如果想阻塞自己的话可以使用函数condition.await()，如果某个线程在进入临界区之后达到了唤醒其他线程的条件，我们则可以使用函数condition.signalAll()唤醒所有被函数await阻塞的线程。

    上面的规则已经将CountDownLatch的整体功能描述清楚了，为了能够将代码解释清楚，我将对应的文字解释放在了代码当中：

    1. import java.util.concurrent.TimeUnit;
    2. import java.util.concurrent.locks.Condition;
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. public class MyCountDownLatch {
    6.     private ReentrantLock lock = new ReentrantLock();
    7.     private Condition condition = lock.newCondition();
    8.     private int curValue;
    9.  
    10.     public MyCountDownLatch(int targetValue) {
    11.         // 我们需要有一个变量去保存计数器的值
    12.         this.curValue = targetValue;
    13.     }
    14.  
    15.     public void countDown() {
    16.         // curValue 是一个共享变量
    17.         // 我们需要用锁保护起来
    18.         // 因此每次只有一个线程进入 lock 保护
    19.         // 的代码区域
    20.         lock.lock();
    21.         try {
    22.             // 每次执行 countDown 计数器都需要减一
    23.             // 而且如果计数器等于0我们需要唤醒哪些被
    24.             // await 函数阻塞的线程
    25.             curValue--;
    26.             if (curValue <= 0)
    27.                 condition.signalAll();
    28.         }catch (Exception ignored){}
    29.         finally {
    30.             lock.unlock();
    31.         }
    32.     }
    33.  
    34.     public void await() {
    35.         lock.lock();
    36.         try {
    37.             // 如果 curValue 的值大于0
    38.             // 则说明 countDown 调用次数还不够
    39.             // 需要将线程挂起 否则直接放行
    40.             if (curValue > 0)
    41.                 // 使用条件变量 condition 将线程挂起
    42.                 condition.await();
    43.         }catch (Exception ignored){}
    44.         finally {
    45.             lock.unlock();
    46.         }
    47.     }
    48. }

    可以使用下面的代码测试我们自己写的CountDownLatch：

    1. public static void main(String[] args) throws InterruptedException {
    2.     MyCountDownLatch latch = new MyCountDownLatch(5);
    3.     for (int i = 0; i < 3; i++) {
    4.         new Thread(() -> {
    5.             latch.countDown();
    6.             System.out.println(Thread.currentThread().getName() + "countDown执行完成");
    7.         }).start();
    8.     }
    9.  
    10.     for (int i = 0; i < 10; i++) {
    11.         new Thread(() -> {
    12.             try {
    13.                 TimeUnit.SECONDS.sleep(2);
    14.             } catch (InterruptedException e) {
    15.                 e.printStackTrace();
    16.             }
    17.             try {
    18.                 latch.await();
    19.             } catch (Exception e) {
    20.                 e.printStackTrace();
    21.             }
    22.             System.out.println(Thread.currentThread().getName() +  "latch执行完成");
    23.         }).start();
    24.     }
    25. }

    CyclicBarrier

    CyclicBarrier有一个路障（同步点），所有的线程到达路障之后都会被阻塞，当被阻塞的线程个数达到指定的数目的时候，就需要对指定数目的线程进行放行。

    • 在CyclicBarrier当中会有一个数据threadCount，表示在路障需要达到这个threadCount个线程的时候才进行放行，而且需要放行threadCount个线程，这里我们可以循环使用函数condition.signal()去唤醒指定个数的线程，从而将他们放行。如果线程需要将自己阻塞住，可以使用函数condition.await()。
    • 在CyclicBarrier当中需要有一个变量currentThreadNumber，用于记录当前被阻塞的线程的个数。
    • 用户还可以给CyclicBarrier传入一个Runnable对象，当放行的时候需要执行这个Runnable对象，你可以新开一个线程去执行这个Runnable对象，或者让唤醒其他线程的这个线程执行Runnable对象。

    根据上面的CyclicBarrier要求，写出的代码如下（分析和解释在注释当中）：

    1. import java.util.concurrent.TimeUnit;
    2. import java.util.concurrent.locks.Condition;
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. public class MyCyclicBarrier {
    6.  
    7.     private ReentrantLock lock = new ReentrantLock();
    8.     private Condition condition = lock.newCondition();
    9.     private int threadCount;
    10.     private int currentThreadNumber;
    11.     private Runnable runnable;
    12.  
    13.     public MyBarrier(int count) {
    14.         threadCount = count;
    15.     }
    16.  
    17.     /**
    18.      * 允许传入一个 runnable 对象
    19.      * 当放行一批线程的时候就执行这个 runnable 函数
    20.      * @param count
    21.      * @param runnable
    22.      */
    23.     public MyBarrier(int count, Runnable runnable) {
    24.         this(count);
    25.         this.runnable = runnable;
    26.     }
    27.  
    28.     public void await() {
    29.         lock.lock();
    30.         currentThreadNumber++;
    31.         try {
    32.             // 如果阻塞的线程数量不到 threadCount 需要进行阻塞
    33.             // 如果到了需要由这个线程唤醒其他线程
    34.             if (currentThreadNumber == threadCount) {
    35.                 // 放行之后需要重新进行计数
    36.                 // 因为放行之后 condition.await();
    37.                 // 阻塞的线程个数为 0
    38.                 currentThreadNumber = 0;
    39.                 if (runnable != null) {
    40.                     new Thread(runnable).start();
    41.                 }
    42.                 // 唤醒 threadCount - 1 个线程 因为当前这个线程
    43.                 // 已经是在运行的状态 所以只需要唤醒 threadCount - 1
    44.                 // 个被阻塞的线程
    45.                 for (int i = 1; i < threadCount; i++)
    46.                     condition.signal();
    47.             }else {
    48.                 // 如果数目还没有达到则需要阻塞线程
    49.                 condition.await();
    50.             }
    51.         }catch (Exception ignored){}
    52.         finally {
    53.             lock.unlock();
    54.         }
    55.     }
    56.  
    57. }
    58.

    下面是测试我们自己写的路障的代码：

    1. public static void main(String[] args) throws InterruptedException {
    2.     MyCyclicBarrier barrier = new MyCyclicBarrier(5, () -> {
    3.         System.out.println(Thread.currentThread().getName() + "开启一个新线程");
    4.         for (int i = 0; i < 1; i++) {
    5.             System.out.println(i);
    6.         }
    7.     });
    8.  
    9.     for (int i = 0; i < 5; i++) {
    10.         new Thread(() -> {
    11.             System.out.println(Thread.currentThread().getName() + "进入阻塞");
    12.             try {
    13.                 TimeUnit.SECONDS.sleep(2);
    14.             } catch (InterruptedException e) {
    15.                 e.printStackTrace();
    16.             }
    17.             barrier.await();
    18.             System.out.println(Thread.currentThread().getName() + "阻塞完成");
    19.         }).start();
    20.     }
    21. }

    Semaphore

    Semaphore可以控制执行某一段临界区代码的线程数量，在Semaphore当中会有两个计数器semCount和curCount。

    • semCount表示可以执行临界区代码的线程的个数。
    • curCount表示正在执行临界区代码的线程的个数。

    这个工具实现起来也并不复杂，具体分析都在注释当中：

    1. import java.util.concurrent.TimeUnit;
    2. import java.util.concurrent.locks.Condition;
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. public class MySemaphore {
    6.  
    7.     private ReentrantLock lock = new ReentrantLock();
    8.     private Condition condition = lock.newCondition();
    9.     private int semCount;
    10.     private int curCount;
    11.  
    12.     public MySemaphore(int semCount) {
    13.         this.semCount = semCount;
    14.     }
    15.  
    16.     public void acquire() {
    17.         lock.lock();
    18.         try {
    19.             // 正在执行临界区代码的线程个数加一
    20.             curCount++;
    21.             // 如果线程个数大于指定的能够执行的线程个数
    22.             // 需要将当前这个线程阻塞起来
    23.             // 否则直接放行
    24.             if (curCount > semCount) {
    25.                 condition.await();
    26.             }
    27.         }catch (Exception ignored) {}
    28.         finally {
    29.             lock.unlock();
    30.         }
    31.     }
    32.  
    33.     public void release() {
    34.         lock.lock();
    35.         try {
    36.             // 线程执行完临界区的代码
    37.             // 将要离开临界区 因此 curCount 
    38.             // 需要减一
    39.             curCount--;
    40.             // 如果有线程阻塞需要唤醒被阻塞的线程
    41.             // 如果没有被阻塞的线程 这个函数执行之后
    42.             // 对结果也不会产生影响 因此在这里不需要进行
    43.             // if 判断
    44.             condition.signal();
    45.             // signal函数只对在调用signal函数之前
    46.             // 被await函数阻塞的线程产生影响 如果
    47.             // 某个线程调用 await 函数在 signal 函数
    48.             // 执行之后，那么前面那次 signal 函数调用
    49.             // 不会影响后面这次 await 函数
    50.         }catch (Exception ignored){}
    51.         finally {
    52.             lock.unlock();
    53.         }
    54.     }
    55. }

    使用下面的代码测试我们自己写的MySemaphore：

    1. public static void main(String[] args) {
    2.     MySemaphore mySemaphore = new MySemaphore(5);
    3.     for (int i = 0; i < 10; i++) {
    4.         new Thread(() -> {
    5.             mySemaphore.acquire();
    6.             System.out.println(Thread.currentThread().getName() + "已经进入临界区");
    7.             try {
    8.                 TimeUnit.SECONDS.sleep(2);
    9.             } catch (InterruptedException e) {
    10.                 e.printStackTrace();
    11.             }
    12.             mySemaphore.release();
    13.             System.out.println(Thread.currentThread().getName() + "已经离开临界区");
    14.         }).start();
    15.     }
    16. }

    总结

    在本文当中主要给大家介绍了三个在并发当中常用的工具类该如何使用，然后介绍了我们自己实现三个工具类的细节，其实主要是利用条件变量实现的，因为它可以实现线程的阻塞和唤醒，其实只要大家了解条件变量的使用方法，和三种工具的需求大家也可以自己实现一遍。

  • 相关阅读:
    数据库定时备份winserver2012篇
    使用setoolkit进行社会工程学攻击获取账号密码
    Java底层HashMap的如何解释？
    MySQL一条查询语句执行流程
    全网最全最通俗易懂的Kafka知识点汇总，入门到精通，完全学会
    要做出高品质的docker镜像，一个靠谱的dockerfile必不可少！
    【ARM Trace32(劳特巴赫) 使用介绍 2 -- Trace32 cmm 脚本基本语法及常用命令】
    【单目3D目标检测】FCOS3D + PGD论文解析与代码复现
    今天的码农女孩开始学习react的知识
    Ruoyi集成flyway后启动报错的解决方法
  • 原文地址：https://blog.csdn.net/weixin_62421895/article/details/125991680