假如有Thread1、Thread2、ThreaD3、Thread4四条线程分别统计C、D、E、F四个盘的大小，所有线程都统计完毕交给Thread5线程去做汇总，应当如何实现？

有两种方法：

　　第一种方法：

一般情况，我们实现多线程都是Thread或者Runnable(后者比较多)，但是，这两种都是没返回值的，所以我们需要使用callable(有返回值的多线程)和future(获得线程的返回值)来实现了。

1. /**
2. * 假如有Thread1、Thread2、ThreaD3、Thread4四条线程分别统计C、D、E、F四个盘的大小，所有线程都统计完毕交给Thread5线程去做汇总，应当如何实现？
3. */
4. public class TestThread {
5. public static void main(String[] args) {
6. ThreadCount tc = null;
7. ExecutorService es = Executors.newCachedThreadPool();//线程池
8. CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(es);
9. for(int i=0;i<4;i++){
10. tc = new ThreadCount(i+1);
11. cs.submit(tc);
12. }
13. // 添加结束，及时shutdown，不然主线程不会结束
14. es.shutdown();
15. int total = 0;
16. for(int i=0;i<4;i++){
17. try {
18. total+=cs.take().get();
19. } catch (InterruptedException e) {
20. e.printStackTrace();
21. } catch (ExecutionException e) {
22. e.printStackTrace();
23. }
24. }
25. System.out.println(total);
26. }
27. }
28. class ThreadCount implements Callable<Integer>{
29. private int type;
30. ThreadCount(int type){
31. this.type = type;
32. }
33. @Override
34. public Integer call() throws Exception {
35. if(type==1){
36. System.out.println("C盘统计大小");
37. return 1;
38. }else if(type==2){
39. Thread.sleep(20000);
40. System.out.println("D盘统计大小");
41. return 2;
42. }else if(type==3){
43. System.out.println("E盘统计大小");
44. return 3;
45. }else if(type==4){
46. System.out.println("F盘统计大小");
47. return 4;
48. }
49. return null;
50. }
51. }

ps：一个需要注意的小细节，cs.take.get()获取返回值，是按照完成的顺序的，即上面案例返回顺序是CEFD

　第二种方法：

第一种方法：

直接用join把线程5加入进去即可

第二种方法：

用Java.util.concurrent下的方法解决

用CountDownLatch : 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行

CountDownLatch 是计数器, 线程完成一个就记一个, 就像 报数一样, 只不过是递减的.

一个例子如下：

1. public class CountDownLatchDemo {
2. final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
3. public static void main(String[] args) throws InterruptedException {
4. CountDownLatch latch=new CountDownLatch(2);//两个工人的协作
5. Worker worker1=new Worker("zhang san", 5000, latch);
6. Worker worker2=new Worker("li si", 8000, latch);
7. worker1.start();//
8. worker2.start();//
9. latch.await();//等待所有工人完成工作
10. System.out.println("all work done at "+sdf.format(new Date()));
11. }
12. static class Worker extends Thread{
13. String workerName;
14. int workTime;
15. CountDownLatch latch;
16. public Worker(String workerName ,int workTime ,CountDownLatch latch){
17. this.workerName=workerName;
18. this.workTime=workTime;
19. this.latch=latch;
20. }
21. public void run(){
22. System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));
23. doWork();//工作了
24. System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));
25. latch.countDown();//工人完成工作，计数器减一
26. }
27. private void doWork(){
28. try {
29. Thread.sleep(workTime);
30. } catch (InterruptedException e) {
31. e.printStackTrace();
32. }
33. }
34. }
35. }

CyclicBarrier        : N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。

这样应该就清楚一点了，对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待， 而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。CyclicBarrier更像一个水闸, 线程执行就想水流, 在水闸处都会堵住, 等到水满(线程到齐)了, 才开始泄流.