CounDownLatch介绍

CounDownLatch

1简介

countDownLatch是在java1.5被引入，跟它一起被引入的工具类还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue

2.CounDownLatch具体是干什么用的，有什么Api

countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
是通过维护一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

2.1 API

//1构造方法 参数count为计数值
public CountDownLatch(int count) {  };  

//2调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };   
//3 与await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
//4 将count值减1
public void countDown() { };  

注： 一般 await（）与 countDown() 方法联合起来使用达到线程所有的都执行完后才会往下执行其他的代码；

3 CounDownLatch 与CyclicBarrier区别

CountDownLatch: 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。
 
 CyclicBrrier: N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待

4简单的使用

package com.momo.spring.builder;

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestDemo {
	private static Random random = new Random(System.currentTimeMillis());
    private static ExecutorService executor = Executors.newFixedThreadPool(2);
    private static final CountDownLatch countDownLatch = new CountDownLatch(11);
    public static void main(String[] args) throws InterruptedException {
        //(1)查询数据
        int[] data = query();
        //(2)并行处理数据
        for(int i = 0; i < data.length; i++) {
            executor.execute(new SimpleRunnable(data, i));
        }
        //(3)
        countDownLatch.await();
        System.out.println("all of work finish done.");
    }
    
    static class SimpleRunnable implements Runnable    {
        private final int[] data;
        private final int index;
        
        public SimpleRunnable(int[] data, int index) {
            this.data = data;
            this.index = index;
        }
        
        @Override
        public void run() {
            try {
                Thread.sleep(random.nextInt(2000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            int value = data[index];
            if(value % 2 == 0) {
                data[index] = value * 2;
            } else {
                data[index] = value * 10;
            }
            countDownLatch.countDown();
            System.out.println(Thread.currentThread().getName() + " finished.");
        }
    }
    
    private static int[] query() {
        return new int[] {0,1,2,3,4,5,6,7,8,9,10};
    }
}

当注掉 countDownLatch.await();这个的时候
结果
当放开 countDownLatch.await()
发现 all of work finish done 在其他十一个线程执行完后才执行
结果

5原理实现
底层依靠 AQS来实现，共享锁维护一个state的状态当其状态为0后才会往下执行