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

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

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

一.使用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();
    }
}

借鉴:https://blog.csdn.net/m0_37882178/article/details/79554997?utm_source=blogxgwz4

文章来源网络,版权归作者本人所有,如侵犯到原作者权益,请与我们联系删除或授权事宜
如果有误,请联系作者更改,谢谢,本人微信:void666666

  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值