CountDownLatch与CyclicBarrier的区别(代码说话,一目了然)

CountDownLatch相信很多人都比较了解,也都使用过,但CyclicBarrier可能就不太了解了,至于它们之间的区别我就曾迷惑过／一段时间.

相比CountDownLatch,CyclicBarrier的本质区别是调用await()的主体不一样,CountDownLatch.await()通常是在主线程(或者叫调用线程)调用的,而CyclicBarrier.await()是在任务线程调用的.

这样就导致了CycliBarrier通常是阻塞的等待其他线程(最终调用CycliBarrier.await()的线程),并由于是在任务线程中await().是不影响主线程的执行的; 而CountDownLatch.await()是阻塞等待的是调用countDown()的线程,并且由于是在主线程中调用的,在任务完成之前会一直阻塞主线程.

当任务线程结束后,CyclicBarrier的计数器会自动减一,而CountDownLatch需要显示地调用countDown()
而至于像CyclicBarrier可以重用,CountDownLatch不可重用这样的区别,只是细枝末节,不是本质区分.

 好了,下面使用代码来说明:

CyclicBarrier示例:

package com.xycode.cyclicBarrierDemo;

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

public class Demo1 {
    /**
     * 相比CountDownLatch,CyclicBarrier的本质区别是等待的主体不一样,CountDownLatch.await()阻塞的是主线程的代码,
     * 而CyclicBarrier.await()阻塞的是当前线程的代码.
     * 至于像CyclicBarrier可以重用,CountDownLatch不可重用这样的区别,只是细枝末节,不是本质区分.
     */
    private static CyclicBarrier cyclicBarrier=new CyclicBarrier(5);

    public static void main(String[] args) {
        Thread[] t=new Thread[5];
        for(int i=0;i<t.length;++i){
            t[i]=new Thread(){
                @Override
                public void run() {
                    try {
                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" start work");
                        TimeUnit.SECONDS.sleep(2);
                        cyclicBarrier.await();
                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" finish work");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            };
        }
        for(int i=0;i<t.length;++i) t[i].start();

//        cyclicBarrier.reset();//显式重置,以便CyclicBarrier重用,不过实际上会自动重置...

        for(int i=0;i<t.length;++i){
            t[i]=new Thread(){
                @Override
                public void run() {
                    try {
                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" start work");
                        TimeUnit.SECONDS.sleep(2);
                        cyclicBarrier.await();

                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" finish work");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            };
        }
        for(int i=0;i<t.length;++i) t[i].start();
    }
}

以上代码输出:

可以看出,尽管在main线程中是分为两段来执行的,但10个线程的start是连在一起输出的,这说明CyclicBarrier.await()阻塞等待的并不是main线程,而是任务线程,观察时间戳,所有任务都在2s之后完成了,确实说明main线程中是连续开启任务的

CountdownLatch示例:

package com.xycode.cyclicBarrierDemo;

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

/**
 * ClassName: test
 *
 * @Author: xycode
 * @Date: 2019/10/25
 **/
public class Demo2 {
    private static CountDownLatch countDownLatch=new CountDownLatch(5);

    public static void main(String[] args) {
        Thread[] t=new Thread[5];
        for(int i=0;i<t.length;++i){
            t[i]=new Thread(){
                @Override
                public void run() {
                    try {
                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" start work");
                        TimeUnit.SECONDS.sleep(2);
                        countDownLatch.countDown();

                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" finish work");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
        }

        for(int i=0;i<t.length;++i) t[i].start();

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        countDownLatch=new CountDownLatch(t.length);

        for(int i=0;i<t.length;++i){
            t[i]=new Thread(){
                @Override
                public void run() {
                    try {
                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" start work");
                        TimeUnit.SECONDS.sleep(2);
                        countDownLatch.countDown();

                        System.out.println(System.currentTimeMillis()/1000%1000+": Thread-"+Thread.currentThread().getId()+" finish work");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
        }
        for(int i=0;i<t.length;++i) t[i].start();

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这段代码的输出:

可以看出,任务是被分成两段的,说明main线程在第一次任务分配后阻塞了一段时间,观察时间戳也可以看出这一点