Java并发编程-并发工具类CountDownLatch、CyclicBarrier、Semaphore、i++

最新推荐文章于 2024-04-28 11:11:38 发布

weixin_44021967

最新推荐文章于 2024-04-28 11:11:38 发布

阅读量305

点赞数

分类专栏：并发编程文章标签：并发编程

本文链接：https://blog.csdn.net/weixin_44021967/article/details/119743339

版权

并发编程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章目录

CountDownLatch

CountDownLatch概念

JavaGuide推荐:https://www.cnblogs.com/Lee_xy_z/p/10470181.html
JavaGuide:https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/multi-thread/AQS%E5%8E%9F%E7%90%86%E4%BB%A5%E5%8F%8AAQS%E5%90%8C%E6%AD%A5%E7%BB%84%E4%BB%B6%E6%80%BB%E7%BB%93.md
CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。

在Thread类中，如果要阻塞当前进程等待其他线程，使用的是join（）方法。

CountDownLatch的用法

CountDownLatch典型用法：1、某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1 countdownLatch.countDown()，当计数器的值变为0时，在CountDownLatch上await()的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

CountDownLatch典型用法：2、实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计算器初始化为1，多个线程在开始执行任务前首先countdownlatch.await()，当主线程调用countDown()时，计数器变为0，多个线程同时被唤醒。

CountDownLatch（倒计时计算器）的两个方法countDown(),await()

方法说明：

（1）public void countDown(): 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少.

（2）public boolean await(long timeout,TimeUnit unit) throws InterruptedException

说明: 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。如果当前计数为零，则此方法立刻返回true值。
出现以下三种情况之前,该线程将一直处于休眠状态:
如果出现以下三种情况,该线程将被await():
　　(1)由于调用countDown()方法，计数到达零；该方法返回true。
　　(2)其他某个线程中断当前线程；抛出InterruptedException异常。
　　(3)已超出指定的等待时间。返回false。

三种情况对应的返回结果: (1)如果计数到达零，则该方法返回true值。 (2)如果当前线程，在进入此方法时已经设置了该线程的中断状态；或者在等待时被中断，则抛出InterruptedException，并且清除当前线程的已中断状态。
(3)如果超出了指定的等待时间，则返回值为false。如果该时间小于等于零，则该方法根本不会等待。

参数：

timeout-要等待的最长时间

unit-timeout 参数的时间单位

如果计数到达零，则返回true；如果在计数到达零之前超过了等待时间，则返回false

抛出：

InterruptedException-如果当前线程在等待时被中断

代码怎么写呢?countDown()应该放在那里呢?

首先在主线程中,初始化一个CountDownLatch,初始值为n(需要并行执行n个线程);countDown()应该方法run方法中,且放在最后一行,表示当前线程执行完毕.

JavaGuide关于CountDownLatch的介绍

CountDownLatch的作用允许count个线程阻塞在一个地方,直到所有线程的任务都执行完毕.
适用于多个线程的任务没有顺序依赖,但是需要返回最终的结果.
JavaGuide上提出了项目中的一个应用场景:

我们要读取处理 6 个文件，这 6 个任务都是没有执行顺序依赖的任务，但是我们需要返回给用户的时候将这几个文件的处理的结果进行统计整理。
为此我们定义了一个线程池和 count 为 6 的CountDownLatch对象。使用线程池处理读取任务，每一个线程处理完之后就将count-1(countDownLatch.countDown()😉，
调用CountDownLatch对象的 await()方法，直到所有文件读取完之后，才会接着执行后面的逻辑。

我碰到的一个简单的小例子就是变量自增:
对比下面两张图片,第二张图片需要事先创建100个线程,创建完成之后,才开启线程执行start()方法,之后使用join()方法保证所有线程执行完毕,然后输出最终结果.
第一张图片创建了先生之后直接start()开启线程执行,在run()方法中,文件完成之后count-1(countDown()方法),最后使用await()方法确保所有线程执行完毕.
在这里插入图片描述

裁判发令与运动员赛跑(这个例子也太好了)

package com.example.demo.CountDownLatchDemo;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountdownLatchTest2 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch cdOrder = new CountDownLatch(1);//一个裁判员
        final CountDownLatch cdAnswer = new CountDownLatch(4);//四个运动员
        for (int i = 0; i < 4; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("选手" + Thread.currentThread().getName() + "正在等待裁判发布口令");
                        cdOrder.await();//裁判员发令完毕,cdOrder=0,此时调用await()方法,返回true,开始执行其他线程
                        System.out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("选手" + Thread.currentThread().getName() + "到达终点");
                        cdAnswer.countDown();//每完成一个线程,就count--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            service.execute(runnable);//调用start()方法,启动线程
        }
        try {
            Thread.sleep((long) (Math.random() * 10000));
            System.out.println("裁判"+Thread.currentThread().getName()+"即将发布口令");
            cdOrder.countDown();//裁判员发令完毕,count--,此时变为0
            System.out.println("裁判"+Thread.currentThread().getName()+"已发送口令，正在等待所有选手到达终点");
            cdAnswer.await();//直到cdAnswer==0,这个方法返回true,接着执行主线程
            System.out.println("所有选手都到达终点");
            System.out.println("裁判"+Thread.currentThread().getName()+"汇总成绩排名");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }
}

Semaphore

信号量
控制同时访问特定资源的线程数量。
应用场景：流量控制，比如数据库连接。

CyclicBarrier同步屏障

可循环使用的的屏障，让一组线程到达一个屏障（同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

CyclicBarrier方法

默认的构造方法：CyclicBarrier（int parties）

await（）：每个线程调用await（）方法，表示到达屏障，当前线程被阻塞。

CyclicBarrier 的使用示例

示例 1：

/**
 *
 * @author Snailclimb
 * @date 2018年10月1日
 * @Description: 测试 CyclicBarrier 类中带参数的 await() 方法
 */
public class CyclicBarrierExample2 {
  // 请求的数量
  private static final int threadCount = 550;
  // 需要同步的线程数量
  private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

  public static void main(String[] args) throws InterruptedException {
    // 创建线程池
    ExecutorService threadPool = Executors.newFixedThreadPool(10);

    for (int i = 0; i < threadCount; i++) {
      final int threadNum = i;
      Thread.sleep(1000);
      threadPool.execute(() -> {
        try {
          test(threadNum);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        } catch (BrokenBarrierException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      });
    }
    threadPool.shutdown();
  }

  public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
    System.out.println("threadnum:" + threadnum + "is ready");
    try {
      /**等待60秒，保证子线程完全执行结束*/
      cyclicBarrier.await(60, TimeUnit.SECONDS);
    } catch (Exception e) {
      System.out.println("-----CyclicBarrierException------");
    }
    System.out.println("threadnum:" + threadnum + "is finish");
  }

}

threadnum:0is ready
threadnum:1is ready
threadnum:2is ready
threadnum:3is ready
threadnum:4is ready
threadnum:4is finish
threadnum:0is finish
threadnum:1is finish
threadnum:2is finish
threadnum:3is finish
threadnum:5is ready
threadnum:6is ready
threadnum:7is ready
threadnum:8is ready
threadnum:9is ready
threadnum:9is finish
threadnum:5is finish
threadnum:8is finish
threadnum:7is finish
threadnum:6is finish
......