JUC-CountDownLatch和CyclicBarrier

2019-02-27  本文已影响0人  AZZCS_0222

CountDownLatch等待多线程完成,该工具类适用于主线程等待其他子线程结束后再执行的场景

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);// 初始化线程个数
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("第一个子线程countDown");
                countDownLatch.countDown();// 线程个数减一
                System.out.println("第一个线程继续运行");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第一个线程继续运行");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("第二个子线程countDown");
                countDownLatch.countDown();// 线程个数减一
                System.out.println("第二个线程继续运行");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第二个线程继续运行");
            }
        }).start();
        countDownLatch.await();
        System.out.println("主线程执行结束");
    }
}

运行结果

第二个子线程countDown
第一个子线程countDown
第二个线程继续运行
第一个线程继续运行
主线程执行结束
第一个线程继续运行
第二个线程继续运行

CyclicBarrier 可循环使用的屏障,使一组线程都达到屏障点的时候才放行。

public class CyclicBarrierTest implements Runnable {
    // 屏障数为4,下面4个子线程都执行到屏障点的时候才放行,this为放行后执行的线程,该线程执行完后才继续执行各个子线程
    private CyclicBarrier cyclicBarrier = new CyclicBarrier(4,this);

    private Executor executor = Executors.newFixedThreadPool(4);
    public AtomicInteger count = new AtomicInteger(0);


    private void count() {
        for(int i = 0;i<4;i++){
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0;j<10;j++) {
                        count.getAndIncrement();
                    }
                    try {
                        System.out.println("子线程等待");
                        cyclicBarrier.await();
                        System.out.println("子线程结束");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    @Override
    public void run() {
        System.out.println("阻塞线程执行");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计数结果:"+count.get());
        System.out.println("阻塞线程结束");
    }

    public static void main(String[] args) {
        CyclicBarrierTest test =new CyclicBarrierTest();
        test.count();
    }

}

CountDownLatch和CyclicBarrier的区别

CountDownLatch : (一个或者多个等待N个)一个线程(或者多个), 等待另外N个线程完成某个事情之后才能执行。对于CountDownLatch来说,重点是那个“一个线程”, 是它在等待, 而另外那N的线程在把“某个事情”做完之后可以继续等待,可以终止。

CyclicBarrier: (N个线程相互等待)任何一个线程完成之前,所有的线程都必须等待。重点是那N个线程,他们之间任何一个没有完成,所有的线程都必须等待。

上一篇下一篇

猜你喜欢

热点阅读