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

本文链接：https://blog.csdn.net/wt520it/article/details/83898767

最近看了一些面试题，然后发现这个频率比较高，然后就细心地了解下

在这里主要想讲解三种方法(毕竟还有其他方法)：

一.使用join方法：

这个是辅助类：
在这里插入图片描述

package com.com.aaa.fiveThreadDemo;

public class FiveThreadJoinMethod {
    public static void main(String[] args) throws InterruptedException{
        FiveThreadJoinMethodUtils ft=new FiveThreadJoinMethodUtils();

        Thread t1=new Thread(ft,"我是线程A");
        Thread t2=new Thread(ft,"我是线程B");
        Thread t3=new Thread(ft,"我是线程C");
        Thread t4=new Thread(ft,"我是线程D");
        Thread t5=new Thread(ft,"我是主线程");

        t1.start();t2.start();t3.start();t4.start();
        t1.join();t2.join();t3.join();
        
        t5.start();
        t5.join();
    }
}

二.利用java.util.concurrent包下的CountDownLatch（减数器）

原理：多个线程之间，等待另外N个线程完成之后，某个线程才能执行

package com.com.aaa.fiveThreadDemo;

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

/**
 * CountDownLatch：一个或者多个线程，等待另外N个线程完成之后才能执行
 */
public class FiveThreadCountDownLatch {
    public static void main(String[] args)throws InterruptedException{
        final CountDownLatch countDownLatch=new CountDownLatch(4);

        Runnable c=new Runnable() {
            @Override
            public void run() {
               try{
                   System.out.println("我是C");
                   Thread.sleep(100);
                   countDownLatch.countDown();  //减少一个
               }catch (Exception e){
                   e.printStackTrace();
               }

            }
        };

        Runnable d=new Runnable() {
            @Override
            public void run() {
                try{
                    System.out.println("我是D");
                    Thread.sleep(100);
                    countDownLatch.countDown();  //减少一个
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        };

        Runnable e=new Runnable() {
            @Override
            public void run() {
                try{
                    System.out.println("我是E");
                    Thread.sleep(100);
                    countDownLatch.countDown();  //减少一个
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        };

        Runnable f=new Runnable() {
            @Override
            public void run() {
                try{
                    System.out.println("我是F");
                    Thread.sleep(100);
                    countDownLatch.countDown();  //减少一个
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        };
        //创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
        ExecutorService service=Executors.newFixedThreadPool(4);
        service.submit(c);
        service.submit(d);
        service.submit(e);
        service.submit(f);

        countDownLatch.await();   //只要检测到当前线程为0就可以继续往下执行
        System.out.println("我是主线程");
        service.shutdown();
    }
}

在这里要说下thread.join和countDownLatch.await()之间的区别：

thread.join()是当前线程执行完毕之后，其他线程才可以执行
countDownLatch()是当线程数量为0的时候，不管其他线程是否执行了，这个线程都要执行的

二.利用java.util.concurrent包下的CyclicBarrier

原理：多个线程之间相互等待，任何一个线程完成之前，所有的线程都必须等待

package com.com.aaa.fiveThreadDemo;

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FiveThreadCyclicBarrier {
    public static void main(String[] args) {

        Runnable maimRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是主线程");
            }
        };
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(4, maimRunnable);

        Runnable c = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("我是C");
                    Thread.sleep(100);
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable d = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("我是D");
                    Thread.sleep(100);
                    cyclicBarrier.await();  
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable e = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("我是E");
                    Thread.sleep(100);
                    cyclicBarrier.await();  
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable f = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("我是F");
                    Thread.sleep(100);
                    cyclicBarrier.await();  
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        //创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
        ExecutorService service = Executors.newFixedThreadPool(4);
        service.submit(c);
        service.submit(d);
        service.submit(e);
        service.submit(f);
        service.shutdown();
    }
}