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. }  
posted @ 2015-12-29 21:46  烟-波-天-客  阅读(2013)  评论(0编辑  收藏  举报