zoukankan      html  css  js  c++  java
  • java 中使用线程池处理文件夹下面的子文件

    读取某个文件夹下面的所有文件,使用多线程处理,例如读取E盘下面的文件内容:

    1. package thread;  
    2.   
    3. import java.io.File;  
    4. import java.util.concurrent.BlockingQueue;  
    5. import java.util.concurrent.ExecutorService;  
    6. import java.util.concurrent.Executors;  
    7. import java.util.concurrent.LinkedBlockingQueue;  
    8.   
    9. public class BigDataFile {  
    10.       
    11.     private class DealFile implements Runnable  
    12.     {  
    13.           
    14.         //存放遍历的结果  
    15.         BlockingQueue<File> bFile = null;  
    16.           
    17.         //每个线程独有的file文件夹  
    18.         File file = null;  
    19.           
    20.         public DealFile(BlockingQueue<File> bFile, File file)  
    21.         {  
    22.             this.bFile = bFile;  
    23.             this.file = file;  
    24.         }  
    25.   
    26.         @Override  
    27.         public void run() {  
    28.             getFileName(file.listFiles());  
    29.         }  
    30.           
    31.         /** 
    32.          * 迭代遍历文件夹。 
    33.          * */  
    34.         private final void getFileName(File[] fileDirectory)  
    35.         {  
    36.             for(File file : fileDirectory)  
    37.             {  
    38.                 if(file.isDirectory())  
    39.                 {  
    40.                     //继续迭代处理  
    41.                     getFileName(file.listFiles());  
    42.                 }  
    43.                 else  
    44.                 {  
    45.                     //输出文件的名称  
    46.                     System.out.println(file.getName());  
    47.                     bFile.add(file);  
    48.                 }  
    49.             }  
    50.         }  
    51.     }  
    52.       
    53.     public static void main(String[] args) throws InterruptedException {  
    54.           
    55.         /** 
    56.          * 由于LinkedBlockingQueue实现是线程安全的,实现了先进先出等特性,是作为生产者消费者的首选,LinkedBlockingQueue  
    57.          * 可以指定容量,也可以不指定,不指定的话,默认最大是Integer.MAX_VALUE, 
    58.          * 其中主要用到put和take方法,put方法在队列满的时候会阻塞直到有队列成员被消费,take方法在队列空的时候会阻塞, 
    59.          * 直到有队列成员被放进来。 
    60.          * */  
    61.         BlockingQueue<File> bFile = new LinkedBlockingQueue<File>();  
    62.           
    63.         //需要遍历的文件夹  
    64.         File file = new File("D://");  
    65.           
    66.         //线程池  
    67.         ExecutorService es = Executors.newCachedThreadPool();  
    68.           
    69.         BigDataFile bf = new BigDataFile();  
    70.           
    71.         /** 
    72.          * new File("D://") 文件夹下面有几个文件夹new 几个线程执行。 
    73.          * */  
    74.         for(File f : file.listFiles())  
    75.         {  
    76.             if(f.isDirectory())  
    77.             {  
    78.                 es.execute(bf.new DealFile(bFile, f));  
    79.             }  
    80.             else  
    81.             {  
    82.                 System.out.println(f.getName());  
    83.                 bFile.add(f);  
    84.             }  
    85.         }  
    86.           
    87.         //关闭线程池  
    88.         es.shutdown();  
    89.     }  
    90.       
    91. }  
  • 相关阅读:
    Spring Boot快速搭建Spring框架
    JVM内存管理机制
    开发者应该掌握的Java代码优化技能
    23种设计模式(8)-外观模式
    1823:【00NOIP提高组】方格取数
    【00NOIP提高组】单词接龙
    1821:【00NOIP提高组】乘积最大
    1820:【00NOIP提高组】进制转换
    时间复杂度比较
    hhhhh我想起来我的账号了
  • 原文地址:https://www.cnblogs.com/xm1-ybtk/p/5087155.html
Copyright © 2011-2022 走看看