并发类CountDownLatch的使用.

介绍：
1.countDownLatch允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助.

2.countDownLatch用给定的计数器初始化, await()方法用作阻塞,直到由于countDown()方法的调用而导致当前计数器达到零,之后所有的等待线程被释放,这是一个一次性的现象,计数器无法重置.
如需重置计算的版本,可使用CyclicBarrier并发类.

3.应用场景中,可作用于任务的拆分,将一个大的任务拆分成若干个小任务,每个小任务由一个线程执行,最后由大任务统一处理任务结果.

代码示例：
1.不使用任何方法多线程运行.

public class JoinCountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1 finish");
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread2 finish");
            }
        });

        thread1.start();
        thread2.start();
        System.out.println("all thread finish");

    }
}

运行多次的结果 大概率是all thread finish先打印.

2.如果我们要使 thread1 ，thread2 执行完,main再继续往下执行.就要使用其他的方法和工具.

2.1使用Thread的join方法,join的作用是使所属的线程对象X正常执行run方法中的任务,而使当前线程Z进行无限期的阻塞.

public class JoinCountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1 finish");
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread2 finish");
            }
        });

        thread1.start();
        thread1.join();
        
        thread2.start();
        thread2.join();
        System.out.println("  all thread finish");

    }
}

这样即可实现我们想要的效果, thread1,thread2执行完, 再执行后面的代码.

2.2.使用countDwonLatch实现.

/**
 * TODO
 * 示例countDownLatch的使用
 *
 * @author 86182
 * @version V1.0
 * @since 2020-11-06 10:31
 */
public class CountDownLatchTest {
    static CountDownLatch countDownLatch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //假设逻辑处理
                    Thread.sleep(1000);
                } catch (Exception e) {
                }
                System.out.println(1);
                countDownLatch.countDown();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //假设逻辑处理
                    Thread.sleep(1000);
                } catch (Exception e) {
                }
                System.out.println(2);
                countDownLatch.countDown();
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(3);
            }
        });
        System.out.println("await before:" + System.currentTimeMillis());
        thread1.start();
        thread2.start();

        countDownLatch.await();

        System.out.println("await after:" + System.currentTimeMillis());
      
        thread3.start();
        System.out.println(4);
    }
}

由结果得知, countDownLatch会阻塞任何线程通过await()，直到countDown方法调用的计数器为零,每调用一个countDown方法,计数器减1,直到计数器减到为零,后续的线程被释放通过.

如计数器不为0,await方法将一直阻塞.
// countDownLatch.countDown(); 将其中的一个方法注释

可以看到线程一直再被阻塞中,无法继续运行后面的代码.

CountDownLatch是个一次性的,多次使用await方法无效.

   System.out.println("await before:" + System.currentTimeMillis());
        thread1.start();
        thread2.start();

        countDownLatch.await();

        System.out.println("await after:" + System.currentTimeMillis());
        thread3.start();
        countDownLatch.await();
        System.out.println(4);

结果：