CountDownLatch的用法

/**
 * @author chenlinguang
 * @create 2018-03-02 15:18
 **/
package com.guang.learning;

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {

    public static void main(String[] args) {
        /* 测试
        * 闭锁：一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
        * 即，一组线程等待某一事件发生，事件没有发生前，所有线程将阻塞等待；
        * 而事件发生后，所有线程将开始执行；闭锁最初处于封闭状态，当事件发生后闭锁将被打开，一旦打开，闭锁将永远处于打开状态。
        * */

//        new TestCountDownLatch().testMultiThreadWait();
//        new TestCountDownLatch().testSingleThreadWait();

    }

    /**
     * 测试： 控制多个线程等待
     */
    public void testMultiThreadWait(){
        //让10个multiThreadTask任务线程等待
        int nThreads = 10;
        CountDownLatch latch = new CountDownLatch(1);

        for(int i=0; i<nThreads; i++){
            new Thread(new multiThreadTask(latch)).start();
        }

        latch.countDown();  //开锁：latch计算器减为0，闭锁打开，那些处于等待的线程开始执行

    }
    class multiThreadTask implements Runnable{
        private CountDownLatch latch;

        public multiThreadTask(CountDownLatch latch) {
            this.latch = latch;
        }

        @Override
        public void run() {
            try {
                latch.await();  //闭锁：相当于此处有个门关着，线程都不能正常向下执行，线程只好在此等待（需要等latch打开才能继续）

                //做任务
                System.out.println(Thread.currentThread().getName() + "开始执行时间：" + System.currentTimeMillis());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 测试： 控制单个线程等待
     */
    public void testSingleThreadWait(){
        CountDownLatch latch = new CountDownLatch(1);

        new Thread(new singleThreadTask(latch)).start();

        try {
            latch.await();  //闭锁：相当于此处有个门关着，当前线程不能正常向下执行，当前线程只好在此等待（需要等latch打开才能继续）
            System.out.println("当前线程继续执行时间：" +System.currentTimeMillis());

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    class singleThreadTask implements Runnable{
        private CountDownLatch latch;

        public singleThreadTask(CountDownLatch latch) {
            this.latch = latch;
        }

        @Override
        public void run() {
            //做任务,为了测试主线程被等待的效果，将此线程任务执行时间延迟
            try {
                Thread.sleep((long) (Math.random() * 5000));
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "开始执行时间：" + System.currentTimeMillis());

            latch.countDown();  //开锁：latch计算器减为0，闭锁打开，那些处于等待的线程开始执行
        }
    }




}