碼上歡樂
相關內容    簡體    繁體

JAVA多線程讀寫文件范例

本文轉載自   查看原文   2014-07-28 21:12   35742    多線程/ io流

   在寫之前先聲明，本文是基於之前在博客園網站上檢索到的一份JAVA多線程讀寫文件的示例，我在寫自己的程序時是在那位作者寫的基礎上做了改良，但已不記得原文的地址。如果有知情者，煩請帖出地址，我在此文上加入引用或轉載。 


    本程序是基於這么一種考慮，某系統后台有個將近2G大小的日志文件，你用任何編輯器去打開它，都將會很困難。針對這樣的大文件解析處理，解決方案是使用多個線程，分割讀取指定的大文件。獲取我們所需要的信息。不多說，上代碼了，有注釋可以幫助理解。 


   

Java代碼   收藏代碼
  1. package com.thread.multipl.mysolution;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.RandomAccessFile;  
  5. import java.util.concurrent.CountDownLatch;  
  6.   
  7. /** 
  8.  * 這個線程用來讀取文件，當獲取到指定關鍵字時，在指定的對象加1 
  9.  * @author 劉峰管理2 
  10.  * 
  11.  */  
  12. public class ReadThread extends Thread{  
  13.   
  14.     //定義字節數組（取水的竹筒）的長度    
  15.     private final int BUFF_LEN = 256;    
  16.     //定義讀取的起始點    
  17.     private long start;    
  18.     //定義讀取的結束點    
  19.     private long end;   
  20.     //將讀取到的字節輸出到raf中  randomAccessFile可以理解為文件流，即文件中提取指定的一部分的包裝對象  
  21.     private RandomAccessFile raf;    
  22.     //線程中需要指定的關鍵字  
  23.     private String keywords;  
  24.     //此線程讀到關鍵字的次數  
  25.     private int curCount = 0;  
  26.     /** 
  27.      * jdk1.5開始加入的類，是個多線程輔助類 
  28.      * 用於多線程開始前統一執行操作或者多線程執行完成后調用主線程執行相應操作的類 
  29.      */  
  30.     private CountDownLatch doneSignal;  
  31.     public ReadThread(long start, long end, RandomAccessFile raf,String keywords,CountDownLatch doneSignal){  
  32.         this.start = start;  
  33.         this.end = end;  
  34.         this.raf  = raf;  
  35.         this.keywords = keywords;  
  36.         this.doneSignal = doneSignal;  
  37.     }  
  38.       
  39.     public void run(){  
  40.         try {  
  41.             raf.seek(start);  
  42.             //本線程負責讀取文件的大小    
  43.             long contentLen = end - start;    
  44.             //定義最多需要讀取幾次就可以完成本線程的讀取    
  45.             long times = contentLen / BUFF_LEN+1;    
  46.             System.out.println(this.toString() + " 需要讀的次數："+times);  
  47.             byte[] buff = new byte[BUFF_LEN];  
  48.             int hasRead = 0;  
  49.             String result = null;  
  50.             for (int i = 0; i < times; i++) {    
  51.                 //之前SEEK指定了起始位置，這里讀入指定字節組長度的內容，read方法返回的是下一個開始讀的position  
  52.                 hasRead = raf.read(buff);  
  53.                  //如果讀取的字節數小於0，則退出循環！ （到了字節數組的末尾）   
  54.                 if (hasRead < 0) {    
  55.                     break;    
  56.                 }    
  57.                 result = new String(buff,"gb2312");  
  58. ///             System.out.println(result);  
  59.                 int count = this.getCountByKeywords(result, keywords);  
  60.                 if(count > 0){  
  61.                     this.curCount += count;  
  62.                 }  
  63.             }  
  64.               
  65.             KeyWordsCount kc = KeyWordsCount.getCountObject();  
  66.   
  67.             kc.addCount(this.curCount);  
  68.               
  69.             doneSignal.countDown();//current thread finished! noted by latch object!  
  70.         } catch (IOException e) {  
  71.             // TODO Auto-generated catch block  
  72.             e.printStackTrace();  
  73.         }  
  74.     }  
  75.   
  76.     public long getStart() {  
  77.         return start;  
  78.     }  
  79.   
  80.     public void setStart(long start) {  
  81.         this.start = start;  
  82.     }  
  83.   
  84.     public long getEnd() {  
  85.         return end;  
  86.     }  
  87.   
  88.     public void setEnd(long end) {  
  89.         this.end = end;  
  90.     }  
  91.   
  92.     public RandomAccessFile getRaf() {  
  93.         return raf;  
  94.     }  
  95.   
  96.     public void setRaf(RandomAccessFile raf) {  
  97.         this.raf = raf;  
  98.     }  
  99.       
  100.     public int getCountByKeywords(String statement,String key){  
  101.         return statement.split(key).length-1;  
  102.     }  
  103.   
  104.     public int getCurCount() {  
  105.         return curCount;  
  106.     }  
  107.   
  108.     public void setCurCount(int curCount) {  
  109.         this.curCount = curCount;  
  110.     }  
  111.   
  112.     public CountDownLatch getDoneSignal() {  
  113.         return doneSignal;  
  114.     }  
  115.   
  116.     public void setDoneSignal(CountDownLatch doneSignal) {  
  117.         this.doneSignal = doneSignal;  
  118.     }  
  119. }  



Java代碼   收藏代碼
  1. package com.thread.multipl.mysolution;  
  2.   
  3. import java.io.File;  
  4. import java.io.RandomAccessFile;  
  5. import java.util.concurrent.CountDownLatch;  
  6.   
  7. public class MultiReadTest {  
  8.   
  9.     /** 
  10.      * 多線程讀取文件測試 
  11.      * @param args 
  12.      */  
  13.     public static void main(String[] args) {  
  14.         // TODO Auto-generated method stub  
  15.         final int DOWN_THREAD_NUM = 10;//起10個線程去讀取指定文件  
  16.         final String OUT_FILE_NAME = "d:\\倚天屠龍記.txt";  
  17.         final String keywords = "無忌";  
  18.          //jdk1.5線程輔助類，讓主線程等待所有子線程執行完畢后使用的類，  
  19.         //另外一個解決方案：自己寫定時器，個人建議用這個類  
  20.         CountDownLatch doneSignal = new CountDownLatch(DOWN_THREAD_NUM);  
  21.         RandomAccessFile[] outArr = new RandomAccessFile[DOWN_THREAD_NUM];  
  22.         try{  
  23.             long length = new File(OUT_FILE_NAME).length();  
  24.             System.out.println("文件總長度："+length+"字節");  
  25.             //每線程應該讀取的字節數    
  26.             long numPerThred = length / DOWN_THREAD_NUM;    
  27.             System.out.println("每個線程讀取的字節數："+numPerThred+"字節");  
  28.           //整個文件整除后剩下的余數    
  29.             long left = length % DOWN_THREAD_NUM;  
  30.             for (int i = 0; i < DOWN_THREAD_NUM; i++) {    
  31.                 //為每個線程打開一個輸入流、一個RandomAccessFile對象，    
  32.                   
  33.                 //讓每個線程分別負責讀取文件的不同部分  
  34.                 outArr[i] = new RandomAccessFile(OUT_FILE_NAME, "rw");    
  35.                 if (i != 0) {    
  36. //    
  37. //                    isArr[i] = new FileInputStream("d:/勇敢的心.rmvb");    
  38.                     //以指定輸出文件創建多個RandomAccessFile對象    
  39.                       
  40.                 }    
  41.                 if (i == DOWN_THREAD_NUM - 1) {    
  42. //                    //最后一個線程讀取指定numPerThred+left個字節    
  43. //                  System.out.println("第"+i+"個線程讀取從"+i * numPerThred+"到"+((i + 1) * numPerThred+ left)+"的位置");  
  44.                     new ReadThread(i * numPerThred, (i + 1) * numPerThred    
  45.                             + left, outArr[i],keywords,doneSignal).start();    
  46.                 } else {    
  47.                     //每個線程負責讀取一定的numPerThred個字節    
  48. //                  System.out.println("第"+i+"個線程讀取從"+i * numPerThred+"到"+((i + 1) * numPerThred)+"的位置");  
  49.                     new ReadThread(i * numPerThred, (i + 1) * numPerThred,    
  50.                             outArr[i],keywords,doneSignal).start();    
  51.                 }    
  52.             }  
  53.         }catch(Exception e){  
  54.             e.printStackTrace();  
  55.         }  
  56. //      finally{  
  57. //            
  58. //      }  
  59.         //確認所有線程任務完成，開始執行主線程的操作  
  60.         try {  
  61.             doneSignal.await();  
  62.         } catch (InterruptedException e) {  
  63.             // TODO Auto-generated catch block  
  64.             e.printStackTrace();  
  65.         }  
  66.         //這里需要做個判斷，所有做read工作線程全部執行完。  
  67.         KeyWordsCount k = KeyWordsCount.getCountObject();  
  68. //      Map<String,Integer> resultMap = k.getMap();  
  69.         System.out.println("指定關鍵字出現的次數："+k.getCount());  
  70.     }  
  71.   
  72. }  



Java代碼   收藏代碼
  1. package com.thread.multipl.mysolution;  
  2.   
  3.   
  4. /** 
  5.  * 統計關鍵字的對象 
  6.  * @author 劉峰管理2 
  7.  * 
  8.  */  
  9.   
  10. public class KeyWordsCount {  
  11.       
  12.     private static KeyWordsCount kc;  
  13.       
  14.     private int count = 0;  
  15.     private KeyWordsCount(){  
  16.           
  17.     }  
  18.       
  19.     public static synchronized KeyWordsCount getCountObject(){  
  20.         if(kc == null){  
  21.             kc = new KeyWordsCount();  
  22.         }  
  23.         return kc;  
  24.     }  
  25.   
  26.     public synchronized void  addCount(int count){  
  27.         System.out.println("增加次數："+count);  
  28.         this.count += count;  
  29.     }  
  30.       
  31.     public int getCount() {  
  32.         return count;  
  33.     }  
  34.   
  35.     public void setCount(int count) {  
  36.         this.count = count;  
  37.     }  
  38.       
  39. }  



運行結果如下： 

引用
文件總長度：2012606字節 
每個線程讀取的字節數：201260字節 
Thread[Thread-0,5,main] 需要讀的次數：787 
Thread[Thread-1,5,main] 需要讀的次數：787 
Thread[Thread-2,5,main] 需要讀的次數：787 
Thread[Thread-3,5,main] 需要讀的次數：787 
Thread[Thread-4,5,main] 需要讀的次數：787 
Thread[Thread-5,5,main] 需要讀的次數：787 
Thread[Thread-6,5,main] 需要讀的次數：787 
Thread[Thread-7,5,main] 需要讀的次數：787 
Thread[Thread-8,5,main] 需要讀的次數：787 
Thread[Thread-9,5,main] 需要讀的次數：787 
增加次數：0 
增加次數：146 
增加次數：432 
增加次數：539 
增加次數：587 
增加次數：717 
增加次數：631 
增加次數：467 
增加次數：665 
增加次數：538 
指定關鍵字出現的次數：4722



我用10個線程去解析金庸大師寫的《倚天屠龍記》，“無忌”這個詞在這部小說中一共出現了4722次。實在找不到再大一些的文件了。倚天屠龍記.txt的大小4M出頭。 

關於CountDownLatch類的作用說明： 
    在API文檔中，已經說明是一個輔助類。用於控制主線程與子線程之間切換的一個工具類。用法網上去搜下。ITEYE里也有人討論過。我在這里使用它解決這樣的問題：在確保10個線程都完成文件的解析工作后，系統調用主線程做剩下該做的事情，即：輸出“出現的次數”。不確保這點的話，會導致執行完第4個線程，后面的線程還沒開始，系統已經做最后一步輸出統計結果，這樣就達不到我們要的效果。這里解決方案有另一個簡單的，自己寫個計數器，從10記到1，10個線程嘛。這個看個人喜好吧。

原文：http://babystudyjava.iteye.com/blog/1732814


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 多線程讀寫文件 java多線程批量讀取文件( 八)--讀寫分離 java多線程-讀寫鎖 多線程讀寫多個文件01 Java多線程之~~~ReadWriteLock 讀寫分離的多線程實現 多線程讀寫文件加鎖與不加鎖 實踐 1-2：多線程讀寫文件 JAVA多線程 & 同步關鍵詞synchronized & ReadWriteLock讀寫文件 C# 多線程文件讀寫整理總結 Java多線程 之 多線程下載文件
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM