Java并发工具类之CountDownLatch和CyclicBarrier

太过爱你忘了你带给我的痛 2023-02-13 11:17 12阅读 0赞

### 文章目录 ###

*   *  介绍
     *  使用场景
     *  API
     *  CountDownLatch
     *   *   *  构造方法
             *  常用方法
             *  示例
     *  CyclicBarrier
     *   *   *  构造方法
             *  常用方法
             *  示例
     *  CountDownLatch和CyclicBarrier不同点

## 介绍 ##

`CountDownLatch` 和 `CyclicBarrier` 是 `Java 并发包`提供的两个非常易用的`线程同步工具类`

## 使用场景 ##

*  `CountDownLatch` 主要用来解决**一个线程等待多个线程的场景**，可以类比旅游团团长要等待所有的游客到齐才能去下一个景点
 *  `CyclicBarrier` 主要用来解决**一组线程之间互相等待**，更像是几个驴友之间不离不弃，互相等待

## API ##

*  [CountDownLatch API][]
 *  [CyclicBarrier API][]

## CountDownLatch ##

#### 构造方法 ####

*  `CountDownLatch(int count)` 初始化计数器`count`

#### 常用方法 ####

*  `void countDown()` 计数器减一
 *  `void await()` 当前线程等待，直到计数器到零，就释放所有等待线程，除非该线程被中断。

#### 示例 ####

假如现在有个需求，在执行完`work()`方法和`work2()`方法后在打印`【测试后】`

public class CountDownLatchDemo { 
        //线程池
        private Executor executor = Executors.newFixedThreadPool(2);
        //初始化计数器为2
        private CountDownLatch latch = new CountDownLatch(2);
    
        @Test
        public void test() { 
            System.out.println("===================测试前==================");
            executor.execute(() -> { 
                work();
                //计数器减1
                latch.countDown();
            });
            System.out.println("===================测试中==================");
            executor.execute(() -> { 
                work2();
                //计数器减1
                latch.countDown();
            });
    
    
            try { 
            	//主线程阻塞，当计数器为0时，释放所有线程，执行打印【测试后】
                latch.await();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("===================测试后==================");
    
        }
    
        public void work() { 
            for (int i = 0; i < 100; i++) { 
                System.out.println(i);
            }
        }
    
        public void work2() { 
            HashMap<String, String> map = new HashMap<>();
            for (int i = 0; i < 100; i++) { 
                map.put(i + "", i + ":value值");
                System.out.println("map的长度为：" + map.size());
            }
    
        }
    }

**结果**

===================测试前==================
    ===================测试中==================
    0
    1
    2
    map的长度为：1
    map的长度为：2
    ...省略...
    ===================测试后==================

执行过程中：主线程阻塞，只有其他两条线程全部执行完之后，主线程才会执行

**另外需要注意的是**，`CountDownLatch` 的计数器是不能循环利用的，也就是说一旦计数器减到 0，再有线程调用 await()，该线程会直接通过。

## CyclicBarrier ##

从单词的角度看是“**循环栅栏**“的意思，也有人翻译为“**Java中关于线程的计数器**”，那么该怎么理解呢？可以类比旅游团团长只有等到所有旅客全部到齐之后，才能参观下一个景点。(旅客有的先到，有的后到，只有全部到齐之后，才会去下一个景点参观)

#### 构造方法 ####

*  `CyclicBarrier(int parties)` 初始化并参与线程的个数（也可理解为计数器个数）
 *  `CyclicBarrier(int parties, Runnable barrierAction)` 带有回调函数，当计数器0时，自动执行回调函数

#### 常用方法 ####

*  `int await()` 当前线程已到栅栏（线程已完成）。可理解为计数器就减1。
 *  `int await(long timeout, TimeUnit unit)` 带有超时机制

`回调函数执行条件`：**必须等到所有线程都达到栅栏，也就是所有线程都完成，计数器为0,才会执行回调函数**

#### 示例 ####

现在模拟一个**龟兔赛跑**的场景，但是有个条件**只有乌龟和兔子都跑到了终点，才能举行颁奖典礼**，可以先思考下，再看下面的demo

import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /** * @author ml * @date 2020/6/8 */
    public class CyclicBarrierDemo2 { 
    
        //线程池
        private static ExecutorService executorService = Executors.newFixedThreadPool(2);
    
        public static void main(String[] args) { 
            CyclicBarrier barrier = new CyclicBarrier(2, () -> { 
                work3();
            });
            //乌龟
            executorService.execute(()->{ 
                for (int i = 1; i < 101; i++) { 
                    work(i);
                }
                try { 
                    barrier.await();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } catch (BrokenBarrierException e) { 
                    e.printStackTrace();
                }
            });
            //兔子
            executorService.execute(()->{ 
                for (int i = 1; i < 101; i++) { 
                    work2(i);
                }
                try { 
                    barrier.await();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } catch (BrokenBarrierException e) { 
                    e.printStackTrace();
                }
            });
    
        }
    
    
        /** * 乌龟跑步 * * @param i */
        public static void work(int i) { 
            System.out.println("乌龟跑了【" + i + "】米");
        }
    
        /** * 兔子跑步 * * @param i */
        public static void work2(int i) { 
            System.out.println("兔子跑了【" + i + "】米");
        }
    
        /** * 上帝颁奖 * * @param */
        public static void work3() { 
            System.out.println("上帝来颁奖了");
        }
    }

## CountDownLatch和CyclicBarrier不同点 ##

*  `CountDownLatch`计数器是一次性的，`CyclicBarrier` 是可循环利用的
 *  `CountDownLatch` 解决一个线程等待多个线程的场景；`CyclicBarrier`解决了一组线程之间互相等待的场景。
 *  `CountDownLatch`没有回调函数；而`CyclicBarrier`有回调函数

**开心一刻**

> 医院重病看护中心，有一重病患者清醒过来，看到护士就问：你说，我的寿命还有多长时间？护士：这个？你得去问阎王！患者：上帝能要我吗？护士：不知道！患者：你们不是天使吗？护士：我们只管接送，不管审批！！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjc0MDUzMA_size_16_color_FFFFFF_t_70]

如果觉得不错，请点个赞哦！

[CountDownLatch API]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html
[CyclicBarrier API]: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjc0MDUzMA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200403114750656.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjc0MDUzMA==,size_16,color_FFFFFF,t_70