CountDownLatch使用

CountDownLatch使用

一、CountDownLatch介绍

1) CountDownLatch一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

2) 有时候会有这样的需求，多个线程同时工作，然后其中几个可以随意并发执行，但有一个线程需要等其他线程工作结束后，才能开始。

3) 举个例子，开启多个线程分块下载一个大文件，每个线程只下载固定的一截，最后由另外一个线程来拼接所有的分段，那么这时候我们可以考虑使用CountDownLatch来控制并发

二、CountDownLatch例子

import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * Created by zhengyong on 16/8/22.
 */
public class CountDownLatchTest {

    public static void main(String[] args) {
        System.out.println("main start.");
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<>();
        executorService.execute(new TaskService(countDownLatch, resultMap, "first"));
        executorService.execute(new TaskService(countDownLatch, resultMap, "second"));
        executorService.execute(new TaskService(countDownLatch, resultMap, "third"));
        try {
            countDownLatch.await(2, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        System.out.println("main finish.");

        for (String key : resultMap.keySet()) {
            System.out.println(String.format("key=%s; value=%s", key, resultMap.get(key)));
        }
    }

    static class TaskService implements Runnable {

        private CountDownLatch                    countDownLatch;

        private ConcurrentHashMap<String, Object> resultMap;

        private String                            param;

        public TaskService(CountDownLatch countDownLatch, ConcurrentHashMap<String, Object> resultMap, String param){
            this.countDownLatch = countDownLatch;
            this.resultMap = resultMap;
            this.param = param;
        }

        @Override
        public void run() {
            try {
                System.out.println("execute task begin.");
                resultMap.put(param, UUID.randomUUID().toString());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("task finish.");
            } finally {
                System.out.println(String.format("the count down param is %s.", param));
                countDownLatch.countDown();
            }
        }
    }
}

运行结果：

main start.
execute task begin.
execute task begin.
execute task begin.
task finish.
task finish.
task finish.
the count down param is second.
the count down param is third.
the count down param is first.
main finish.
key=third; value=8762cdd0-3db7-4e97-a5cb-b7d3344117a0
key=first; value=5782e550-8637-49c5-8e82-7d9ec3d833d0
key=second; value=46cfb2c5-26b4-464d-b399-7d9bdd4ef100