多线程读取文件File

Java代码  

1. import java.io.*;  
2. class DownThread extends Thread {  
3.     //定义字节数组（取水的竹筒）的长度  
4.     private final int BUFF_LEN = 32;  
5.     //定义读取的起始点  
6.     private long start;  
7.     //定义读取的结束点  
8.     private long end;  
9.     //读取文件对应的输入流  
10.     private InputStream is;  
11.     //将读取到的字节输出到raf中  
12.     private RandomAccessFile raf;  
13.   
14.     //构造器，传入输入流，输出流和读取起始点、结束点  
15.     public DownThread(long start, long end, InputStream is, RandomAccessFile raf) {  
16.         //输出该线程负责读取的字节位置  
17.         System.out.println(start + "---->" + end);  
18.         this.start = start;  
19.         this.end = end;  
20.         this.is = is;  
21.         this.raf = raf;  
22.     }  
23.   
24.     public void run() {  
25.         try {  
26.             is.skip(start);  
27.             raf.seek(start);  
28.             //定义读取输入流内容的的缓存数组（竹筒）  
29.             byte[] buff = new byte[BUFF_LEN];  
30.             //本线程负责读取文件的大小  
31.             long contentLen = end - start;  
32.             //定义最多需要读取几次就可以完成本线程的读取  
33.             long times = contentLen / BUFF_LEN + 4;  
34.             //实际读取的字节数  
35.             int hasRead = 0;  
36.             for (int i = 0; i < times; i++) {  
37.                 hasRead = is.read(buff);  
38.                 //如果读取的字节数小于0，则退出循环！  
39.                 if (hasRead < 0) {  
40.                     break;  
41.                 }  
42.                 raf.write(buff, 0, hasRead);  
43.             }  
44.         } catch (Exception ex) {  
45.             ex.printStackTrace();  
46.         }  
47.         //使用finally块来关闭当前线程的输入流、输出流  
48.         finally {  
49.             try {  
50.                 if (is != null) {  
51.                     is.close();  
52.                 }  
53.                 if (raf != null) {  
54.                     raf.close();  
55.                 }  
56.             } catch (Exception ex) {  
57.                 ex.printStackTrace();  
58.             }  
59.         }  
60.     }  
61. }  
62.   
63. public class MutilDown {  
64.     public static void main(String[] args) {  
65.         final int DOWN_THREAD_NUM = 4;  
66.         final String OUT_FILE_NAME = "d:/copy勇敢的心.rmvb";  
67.         InputStream[] isArr = new InputStream[DOWN_THREAD_NUM];  
68.         RandomAccessFile[] outArr = new RandomAccessFile[DOWN_THREAD_NUM];  
69.         try {  
70.   
71.             isArr[0] = new FileInputStream("d:/勇敢的心.rmvb");  
72.             long fileLen = getFileLength(new File("d:/勇敢的心.rmvb"));  
73.             System.out.println("文件的大小" + fileLen);  
74.             //以输出文件名创建第一个RandomAccessFile输出流  
75.             outArr[0] = new RandomAccessFile(OUT_FILE_NAME, "rw");  
76.             //创建一个与文件相同大小的空文件  
77.             for (int i = 0; i < fileLen; i++) {  
78.                 outArr[0].write(0);  
79.             }  
80.             //每线程应该读取的字节数  
81.             long numPerThred = fileLen / DOWN_THREAD_NUM;  
82.             //整个文件整除后剩下的余数  
83.             long left = fileLen % DOWN_THREAD_NUM;  
84.             for (int i = 0; i < DOWN_THREAD_NUM; i++) {  
85.                 //为每个线程打开一个输入流、一个RandomAccessFile对象，  
86.                 //让每个线程分别负责读取文件的不同部分。  
87.                 if (i != 0) {  
88.   
89.                     isArr[i] = new FileInputStream("d:/勇敢的心.rmvb");  
90.                     //以指定输出文件创建多个RandomAccessFile对象  
91.                     outArr[i] = new RandomAccessFile(OUT_FILE_NAME, "rw");  
92.                 }  
93.                 if (i == DOWN_THREAD_NUM - 1) {  
94.                     //最后一个线程读取指定numPerThred+left个字节  
95.                     new DownThread(i * numPerThred, (i + 1) * numPerThred  
96.                             + left, isArr[i], outArr[i]).start();  
97.                 } else {  
98.                     //每个线程负责读取一定的numPerThred个字节  
99.                     new DownThread(i * numPerThred, (i + 1) * numPerThred,  
100.                             isArr[i], outArr[i]).start();  
101.                 }  
102.             }  
103.         } catch (Exception ex) {  
104.             ex.printStackTrace();  
105.         }  
106.     }  
107.   
108.     public static long getFileLength(File file) {  
109.         long length = 0;  
110.         //获取文件的长度  
111.         long size = file.length();  
112.         length = size;  
113.         return length;  
114.     }  
115. } 
     

 

转载于:https://www.cnblogs.com/J2EEPLUS/archive/2012/05/07/2488008.html