【多线程并发编程】十三 CountDownLatch和CyclicBarrier

程序猿学社的GitHub,欢迎Star
https://github.com/ITfqyd/cxyxs
本文已记录到github,形成对应专题。

前言

jdk1.5以后,增加了不少内容,我们就来看一看CountDownLatch和CyclicBarrier,实际上,很多的方法,如果实际开发过程中,没有用到过,我们几乎都不怎么熟悉。一切的一切,都感觉十分的陌生。

1.CountDownLatch

概念

允许一个或多个线程等待直到在其他线程执行完毕后再执行。

  • CountDownLatch用给定的计数初始化
  • await方法阻塞
  • 直到countDown()方法的调用而导致当前计数达到零,之后所有等待线程被释放,并且任何后续的await 调用立即返回。

常用api接口

方法 描述
await() 导致当前线程等到锁存器计数到零,除非线程是 interrupted 。线程处于休眠状态,直到计数为0
countDown() 减少锁存器的计数(调用一次,计数减去1),如果计数达到零,释放所有等待的线程。

应用场景

现在是疫情期间,为了保证员工的安全,减少与他们接触的机会,某某公司,实行车接车送。所有人员就位后,司机需要向HR汇报,人员上车情况。

实战

demo案例

package com.cxyxs.thread.thirteen;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Description:转发请注明来源  程序猿学社 - https://ithub.blog.csdn.net/
 * Author: 程序猿学社
 * Date:  2020/3/3 16:24
 * Modified By:
 */
public class Emp {
      //初始化为3,标识有3个员工需要等待
      public static CountDownLatch countDownLatch = new CountDownLatch(3);

    /**
     * 员工正在上车中
     */
    public void toAddress(){
       System.out.println(Thread.currentThread().getName()+"正在步行去固定的上车地点...");
       //模拟去固定地点上车的过程
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        countDownLatch.countDown();
        System.out.println(Thread.currentThread().getName()+"已上车");
    }
}

调用类

package com.cxyxs.thread.thirteen;

/**
 * Description:转发请注明来源  程序猿学社 - https://ithub.blog.csdn.net/
 * Author: 程序猿学社
 * Date:  2020/3/3 16:22
 * Modified By:
 */
public class Demo1 {
    public static void main(String[] args) {
        Emp emp = new Emp();
        //使用lambda方式实现一个线程
        new Thread(()->{
            emp.toAddress();
        },"张三").start();
        new Thread(()->{
            emp.toAddress();
        },"李四").start();
        new Thread(()->{
            emp.toAddress();
        },"王五").start();


        new Thread(()->{
            try {
                emp.countDownLatch.await();
                System.out.println(Thread.currentThread().getName()+"向HR汇报上车情况!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"黄师傅").start();
    }
}

  • 初始化计数为3,调用countDown方法后,每次减去1,一直到零,就会主动释放,继续await后面的代码。
  • 在实际使用过程中,一定要记得调用一次,就调用countDown方法,不然,线程会一直堵塞在哪里。

源码分析

CountDownLatch初始化

 public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
}
  • 初始化一个CountDownLatch对象,需要给定计数的初始值,如果<0,则会抛出异常。
  • 创建了一个Sync对象。
 /**
     * Synchronization control For CountDownLatch.
     * Uses AQS state to represent count.
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);
        }
        protected final void setState(int newState) {
        state = newState;
        }
    }
    private volatile int state;
    private final Sync sync;
  • 首先调用Sync的构造方法。该构造方法会调用setState方法。
  • sync继承AbstractQueuedSynchronizer抽象类,其中有一个变量state,就是为了同步状态的。注意,他的前面有volatile关键字,表示线程之间是可见的,只要值有变动,其他的项目都会知道。类似于开发过程中,某某提交了代码,但是,不说明,其他的人,只有更新代码的时候,发现起冲突才知道,改了同一个文件,而可见性,就是,某人一改代码,马上,就全网通知,说我改代码了,你们都拉取一下最新的代码。

countDown方法

  public void countDown() {
        sync.releaseShared(1);
    }
  • 调用AbstractQueuedSynchronizer方法
 public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }
  • 调用了两个方法tryReleaseShared和doReleaseShared
 protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
  • 获取state的数量,也就是计数器的值,如果为0直接返回false。表示计数已经完成。
  • compareAndSetState方法我们一步步跟踪下去,发现调用的compareAndSwapInt被native关键字修饰,说明是调用的事c或者c++的方法。利用了CAS,这里不过多阐述,可以理解为乐观锁, 但是,可以保证该变量是原子的。代码块,就无法保证了。说到原子,我们就可以联想起多个线程操作i++线程不安全的问题。这也是一到面试经常会的题目。
  • -1完后,再次检查是否为0,如果为0表示计数已完成。

await方法

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
}
  • 实际上是调用父类的acquireSharedInterruptibly方法
 public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }
  • 判断当前线程是否中断,如果中断则抛出InterruptedException异常。
  • tryAcquireShared的返回值小于才会调用doAcquireSharedInterruptibly方法
tryAcquireShared代码
   protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
  • 判断state的计算是否为0,如果为0返回1.

2 CyclicBarrier

概念

实现让所有线程全部等待彼此达到共同屏障点之后,才能同时执行。循环阻塞在涉及固定大小的线程方的程序中很有用,这些线程必须等待彼此,屏障又被称为循环 ,因为它可以在等待的线程被释放之后重新使用。

  • 可以简单的理解为CyclicBarrier是一个减1操作,CountDownLatch是加一操作。

常用api接口

方法 描述
CyclicBarrier(int parties) 创建一个新的 CyclicBarrier ,当给定数量的线程(线程)等待它,达到这个数量时,所有达到共同屏障昨天的线程都会继续运行
CyclicBarrier(int parties, Runnable barrierAction) 类似于上面这种,只是多一个一个参数,可以理解为行为,也就是说,达到固定线程数后,就会执行runnable里面的行为代码
await() 等待所有线程都已调用await方法
  • 这里列举一些常用的api接口,详情的api接口,请查看jdk的api文档

应用场景

  • 大部分的公司,每年都有一次聚会,公司会包一辆大巴车,而大巴车,需要等所有人都到达后,才能出发。

实战

package com.cxyxs.thread.thirteen;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * Description:
 * Author: 程序猿学社
 * Date:  2020/3/6 8:18
 * Modified By:
 */
public class CyclicBarrierTest {
    public static void main(String[] args) {
        final CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
            @Override
            public void run() {
                //达到固定屏障数量后,就会触发
                System.out.println("人员已到期,司机开始发车!");
            }
        });

        for (int i = 0; i < 3; i++) {
            final  int index =i;
            //使用lambda
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+",开始上车");
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+",上车完毕,当前时间:"+System.currentTimeMillis());
            },"员工"+i).start();
        }
    }
}

  • 模拟3个员工,他们公司旅游,大巴司机发现人齐,就发车的一个场景
  • final关键字,注意Thread中是无法直接使用外面的i,所以引入一个中间变量,用final修饰。
  • 使用了lambda表达式,实现一个线程,让代码更简洁。
  • 发现每个员工上车后,就调用await方法,在等待其他的员工,人员一齐,司机就马上发车。
  • 后面,还有一句话,上车完毕和当前时间,实际上也就是在调用await方法后,打印的一句话,为什么这样设计? 实际上,就是更直观的,让我们知道,达到固定屏障数量后,所有的线程就会被唤醒,继续运行,这也是我们概念里面写的同时执行
©️2020 CSDN 皮肤主题: 程序猿惹谁了 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值