zoukankan      html  css  js  c++  java
  • 有Thread1、Thread2、Thread3、Thread4四条线程分别统计C、D、E、F四个盘的大小,所有线程都统计完毕交给Thread5线程去做汇总,应当如何实现?

    利用java.util.concurrent包下的CountDownLatch(减数器)或CyclicBarrier(循环栅栏)

    转自:http://www.cnblogs.com/westward/p/7144620.html

    实现1:用concurrent包下的CountDownLatch

    /**
     * 假如有Thread1、Thread2、Thread3、Thread4四条线程分别统计C、D、E、F四个盘的大小,所有线程都统计完毕交给Thread5线程去做汇总,应当如何实现?
     * 本例,用CountDownLatch实现,CountDownLatch相当于一个计时器
     * */
    
    public class Test1_1 {
        
        public static void main(String[] args) throws InterruptedException {
            //创建一个能容纳4个线程的减数器
            final CountDownLatch countDownLatch= new CountDownLatch(4);
            Runnable run1= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("统计C盘");
                        countDownLatch.countDown();//单任务,把计数器减1
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            Runnable run2= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("统计D盘");
                        countDownLatch.countDown();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            Runnable run3= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("统计E盘");
                        countDownLatch.countDown();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            Runnable run4= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("统计F盘");
                        countDownLatch.countDown();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            
            ExecutorService service= Executors.newFixedThreadPool(4);
            service.submit(run1);
            service.submit(run2);
            service.submit(run3);
            service.submit(run4);
            /*new Thread(run1).start();
            new Thread(run2).start();
            new Thread(run3).start();
            new Thread(run4).start();*/
            
            countDownLatch.await();//主线程,即第5线程等待
            System.out.println("合计C,D,E,F");
            service.shutdown();

    实现2:用concurrent包下的CyclicBarrier

    /**
     * 假如有Thread1、Thread2、Thread3、Thread4四条线程分别统计C、D、E、F四个盘的大小,所有线程都统计完毕交给Thread5线程去做汇总,应当如何实现?
     * 本例,用CyclicBarrier实现,CyclicBarrier相当于一个栅栏,会将线程挡住
     * */
    
    public class Test1_2 {
        public static void main(String[] args) {
            Runnable barrierAction= new Runnable() {
                
                @Override
                public void run() {
                    System.out.println("统计C,D,E,F盘");
                }
            };
            
            final CyclicBarrier cyclicBarrier= new CyclicBarrier(4, barrierAction );
            Runnable run1= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("C盘");
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    
                }
            };
            Runnable run2= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("D盘");
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    
                }
            };
            Runnable run3= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("E盘");
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    
                }
            };
            Runnable run4= new Runnable() {
                
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("F盘");
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    
                }
            };
            
            ExecutorService service= Executors .newFixedThreadPool(4);
            service.submit(run1);
            service.submit(run2);
            service.submit(run3);
            service.submit(run4);
            service.shutdown();
            
            
        }
    }
  • 相关阅读:
    行列转换等经典SQL语句
    [jQuery]使用jQuery.Validate进行客户端验证(中级篇上)——不使用微软验证控件的理由
    深入分析jQuery.prototype.init选择器源码
    浅析jQuery基础框架
    GCC入门 ——-转载
    [转载]在VC中使用 Flash 美化你的程序
    用VS调试 javascript
    如何提高程序性能
    线程安全的懒单例模版类
    各种计算机语言的经典书籍 (转载)
  • 原文地址:https://www.cnblogs.com/lxcmyf/p/7436453.html
Copyright © 2011-2022 走看看