java多线程读写文件实例

Java多线程读文件:

[java]  view plain copy
  1. package com.myjava;  
  2. import java.io.BufferedReader;  
  3. import java.io.FileNotFoundException;  
  4. import java.io.FileReader;  
  5. import java.io.IOException;  
  6. import java.util.ArrayList;  
  7. import java.util.List;  
  8. public class ThreadReadDemo {  
  9.   
  10.     /**Java多线程读大文件 
  11.      * @param args 
  12.      */  
  13.     public static void main(String[] args) {  
  14.         Thread t1=new Thread(new MultiThread(),"A");  
  15.         Thread t2=new Thread(new MultiThread(),"B");  
  16.         t1.start();  
  17.         t2.start();  
  18.     }  
  19.   
  20. }  
  21.   
  22.   
  23.  class MultiThread implements Runnable{   
  24.     private static BufferedReader br = null;  
  25.     private List<String> list;  
  26.       
  27.     static{  
  28.         try {  
  29.             br = new BufferedReader(new FileReader("F://ThreadDemo.txt"),10);  
  30.         } catch (FileNotFoundException e) {  
  31.             // TODO Auto-generated catch block  
  32.             e.printStackTrace();  
  33.         }  
  34.     }  
  35.       
  36.     public void run() {  
  37.         String line = null;  
  38.         int count = 0;  
  39.         while(true) {  
  40.             //System.out.println(Thread.currentThread().getName());  
  41.             this.list = new ArrayList<String>();  
  42.             synchronized(br) {  
  43.                 try {  
  44.                     while((line = br.readLine()) != null) {  
  45.                         if(count<15) {  
  46.                             list.add(line);  
  47.                             count++;  
  48.                         }else {  
  49.                             list.add(line);  
  50.                             count = 0;  
  51.                             break;  
  52.                         }  
  53.                     }  
  54.                 } catch (IOException e) {  
  55.                     e.printStackTrace();  
  56.                 }  
  57.             }  
  58.             try {  
  59.                 Thread.sleep(1);  
  60.                 display(this.list);  
  61.             } catch (InterruptedException e) {  
  62.                 e.printStackTrace();  
  63.             }  
  64.             if(line == null)  
  65.                 break;  
  66.         }  
  67.           
  68.           
  69.     }  
  70.       
  71.     public void display(List<String> list) {  
  72.         for(String str:list) {  
  73.             System.out.println(str);  
  74.         }  
  75.         System.out.println(list.size());  
  76.     }  
  77.       
  78. }  

java多线程写文件:

[java]  view plain copy
  1. package com.myjava;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.util.concurrent.ConcurrentLinkedQueue;  
  8.   
  9. /** 
  10.  * 多线程下写文件 
  11.  *  
  12.  * @author Administrator 
  13.  *  
  14.  */  
  15. public class ThreadDemo {  
  16.   
  17.     public static void main(String[] args) {  
  18.         File file=new File("F:"+File.separator+"ThreadDemo.txt");  
  19.         try {  
  20.             FileOutputStream out=new FileOutputStream(file, true);  
  21.             ConcurrentLinkedQueue<String> queue=new ConcurrentLinkedQueue<String>();  
  22.             for(int i=0;i<10;i++){  
  23.                 new Thread(new MyThread(queue,"线程"+i+",")).start();//多线程往队列中写入数据  
  24.             }  
  25.             new Thread(new DealFile(out,queue)).start();//监听线程,不断从queue中读数据写入到文件中  
  26.             try {  
  27.                 Thread.sleep(3000);  
  28.                 if(!Thread.currentThread().isAlive()){  
  29.                     System.out.println("线程已结束");  
  30.                 }  
  31.             } catch (InterruptedException e) {  
  32.                 // TODO Auto-generated catch block  
  33.                 e.printStackTrace();  
  34.             }  
  35.               
  36.         } catch (FileNotFoundException e) {  
  37.             e.printStackTrace();  
  38.         }  
  39.           
  40.     }  
  41. }  
  42.   
  43. /** 
  44.  * 将要写入文件的数据存入队列中 
  45.  *  
  46.  * @author Administrator 
  47.  *  
  48.  */  
  49. class MyThread implements Runnable {  
  50.     private ConcurrentLinkedQueue<String> queue;  
  51.     private String contents;  
  52.   
  53.     public MyThread() {  
  54.     }  
  55.   
  56.     public MyThread(ConcurrentLinkedQueue<String> queue, String contents) {  
  57.         this.queue = queue;  
  58.         this.contents = contents;  
  59.     }  
  60.   
  61.     @Override  
  62.     public void run() {  
  63.         try {  
  64.             Thread.sleep(100);  
  65.         } catch (InterruptedException e) {  
  66.             // TODO Auto-generated catch block  
  67.             e.printStackTrace();  
  68.         }  
  69.         queue.add(contents);  
  70.     }  
  71. }  
  72. /** 
  73.  * 将队列中的数据写入到文件 
  74.  * @author Administrator 
  75.  * 
  76.  */  
  77. class DealFile implements Runnable {  
  78.     private FileOutputStream out;  
  79.     private ConcurrentLinkedQueue<String> queue;  
  80.   
  81.     public DealFile() {  
  82.     }  
  83.   
  84.     public DealFile(FileOutputStream out, ConcurrentLinkedQueue<String> queue) {  
  85.         this.out = out;  
  86.         this.queue = queue;  
  87.     }  
  88.   
  89.     @Override  
  90.     public void run() {  
  91.         synchronized (queue) {  
  92.             while (true) {  
  93.                 if (!queue.isEmpty()) {  
  94.                     try {  
  95.                         out.write(queue.poll().getBytes("UTF-8"));  
  96.                     } catch (IOException e) {  
  97.                         // TODO Auto-generated catch block  
  98.                         e.printStackTrace();  
  99.                     }  
  100.                 }  
  101.                 try {  
  102.                     Thread.sleep(100);  
  103.                 } catch (InterruptedException e) {  
  104.                     e.printStackTrace();  
  105.                 }  
  106.             }  
  107.         }  
  108.   
  109.     }  
  110.   
  111. }  

你可能感兴趣的:(java多线程读写文件实例)