我用了四条输入线程，加四条输出线程，来拷贝源文件，
结果还是慢了电脑自带的慢一大截。
希望大神能给个超电脑的。。
下面是我用多线程重新做的大文件拷贝程序：

1. import java.io.IOException;
   
2. 
   
3. /*
   
4. * 将一个电影文件，拷贝到其他盘。模拟下载，要求使用多线程
   
5. * 分析：
   
6. * 1，通过File对象关联源文件，并获取其大小。
   
7. * 2，通过File对象创建一个和源文件大小相同的（空）文件
   
8. * 3，通过随机流RandomAccessFile读取源文件，
   
9. * 4，将读取的数据写入到输出管道流PipedOutputStream，
   
10. * 5，管道读取流PipedInputStream读取输出流中的数据，并通过随机流写入到目的文件中。
    
11. *
    
12. 
    
13. */
    
14. 
    
15. 
    
16. 
    
17. public class TestTwo {
    
18. 
    
19.         public static void main(String[] args) throws IOException {
    
20. Copy.copy("C:\\Mon.mp4","C:\\Moncy.mp4");
    
21.         }
    
22. 
    
23. }

复制代码

Copy进行拷贝操作：

1. import java.io.File;
   
2. import java.io.IOException;
   
3. import java.io.PipedInputStream;
   
4. import java.io.PipedOutputStream;
   
5. import java.io.RandomAccessFile;
   
6. 
   
7. public class Copy {
   
8. 
   
9.         public static void main(String[] args) {
   
10. 
    
11.         }
    
12. 
    
13.         public static boolean copy(String source, String destination) throws IOException  {
    
14.                 File socefile = new File(source);
    
15.                 File destfile = new File(destination);
    
16.                 if(socefile.isHidden())
    
17.                         throw new RuntimeException("源文件不可操作");
    
18.                
    
19.                 //目的文件初始化，使其和源文件大小一致。
    
20.                 RandomAccessFile soceRaf = new RandomAccessFile(socefile,"r");
    
21.                 RandomAccessFile destRaf = new RandomAccessFile(destfile,"rwd");
    
22.                 destRaf.setLength(soceRaf.length());
    
23.                 long index = soceRaf.getFilePointer();
    
24.                 soceRaf.close();
    
25.                 destRaf.close();
    
26.                
    
27.                 //把源文件切成4段，每段的最小的（最接近负无穷大）double 值，该值大于等于参数，
    
28.                 //保证数据不丢失。最后一段单独处理，因为数据可能会小于len。
    
29.                 long len = (long) Math.ceil(socefile.length()/4);
    
30.                 for(int x=0 ; x<4 ; x++){
    
31.                         PipedOutputStream pos = new PipedOutputStream();
    
32.                         PipedInputStream pis = new PipedInputStream(pos);
    
33.                         //为了使每个线程都有一个自己独立的指针，为每个对象建立独自的随机流
    
34.                         new Thread(new PipedOut
    
35.                                 (pos,new RandomAccessFile(socefile,"r"),index,len)).start();;
    
36.                         new Thread(new PipedIn
    
37.                                 (pis,new RandomAccessFile(destfile,"rwd"),index,len)).start();
    
38.                         index = index + len ;
    
39.                 }
    
40.                
    
41.                 return true;
    
42.                
    
43.                 /*无限代码，用于测试的
    
44.                  * PipedOutputStream pos = new PipedOutputStream();
    
45.                 PipedInputStream pis = new PipedInputStream(pos);
    
46.                 long len = soceRaf.length();
    
47.                 new Thread(new PipedOut(pos,soceRaf,index,len)).start();
    
48.                 new Thread(new PipedIn(pis,destRaf,index,len)).start();
    
49.                 */
    
50.                
    
51.                
    
52.                
    
53.                
    
54.         }
    
55. 
    
56. }
    

复制代码

PipedOut :通过随机流读取，并写入到管道流中：

1. import java.io.BufferedOutputStream;
   
2. import java.io.IOException;
   
3. import java.io.PipedOutputStream;
   
4. import java.io.RandomAccessFile;
   
5. 
   
6. public class PipedOut implements Runnable{
   
7.         BufferedOutputStream pos;
   
8.         RandomAccessFile soceRaf;
   
9.         long index;
   
10.         long len;
    
11.         PipedOut(PipedOutputStream pos, RandomAccessFile soceRaf, long index, long len) {
    
12.                 super();
    
13.                 this.pos = new BufferedOutputStream(pos);
    
14.                 this.soceRaf = soceRaf;
    
15.                 this.index = index;
    
16.                 this.len = len;
    
17.         }
    
18.         public void run() {
    
19.                
    
20.                 try {
    
21.                         byte[] buf = new byte[1024*1024*20];
    
22.                         int length = 0 ;
    
23.                         soceRaf.seek(index);//设置指针位置
    
24.                         //如果没有循环超出数据位置，或者在到结尾。
    
25.                         while(soceRaf.getFilePointer()<index+len){
    
26.                                 if((length=soceRaf.read(buf))!=-1){
    
27.                                         pos.write(buf,0,length);
    
28.                                         pos.flush();
    
29.                                 }
    
30.                                 else
    
31.                                         break;
    
32.                         }
    
33.                 //如果是因为循环超出数据位置导致的结束,则计算出有效的数组长度
    
34.                         if(length==buf.length){
    
35.                                  length =(int) ((long)length - ( soceRaf.getFilePointer()-(index+len) ));
    
36.                                  System.out.println(length);
    
37.                                 pos.write(buf,0,length);
    
38.                         }
    
39.                         pos.close();
    
40.                         soceRaf.close();
    
41.                 }
    
42.                 catch (IOException e) {
    
43.                         e.printStackTrace();
    
44.                 }
    
45.                
    
46.                
    
47. 
    
48.                 /*
    
49.                  * 无效代码用于测试的
    
50.                 try {
    
51.                         byte[] buf = new byte[1024*100];
    
52.                         int length = 0 ;
    
53.                         soceRaf.seek(index);//设置指针位置
    
54.                         //如果没有循环超出数据位置，或者在到结尾。
    
55.                         while((length=soceRaf.read(buf))!=-1){
    
56.                                 pos.write(buf,0,length);
    
57.                                 pos.flush();
    
58.                         }
    
59.                         pos.close();
    
60.                         soceRaf.close();
    
61.                 }
    
62.                 catch (IOException e) {
    
63.                         e.printStackTrace();
    
64.                 }
    
65.                 */
    
66.                
    
67.         }
    
68.        
    
69. 
    
70. }
    

复制代码

PipedIn 从管道流中读取数据，并通过任意流写入到目的文件中：

1. import java.io.BufferedInputStream;
   
2. import java.io.IOException;
   
3. import java.io.PipedInputStream;
   
4. import java.io.RandomAccessFile;
   
5. 
   
6. public class PipedIn implements Runnable {
   
7. 
   
8.         BufferedInputStream pis;
   
9.         RandomAccessFile destRaf;
   
10.         long index;
    
11.         long len;
    
12.        
    
13.         PipedIn(PipedInputStream pis, RandomAccessFile destRaf, long index, long len) {
    
14.                 super();
    
15.                 this.pis =new BufferedInputStream(pis);
    
16.                 this.destRaf = destRaf;
    
17.                 this.index = index;
    
18.                 this.len = len;
    
19.         }
    
20. 
    
21.         public void run() {
    
22.                
    
23.                 try {
    
24.                         byte[] buf = new byte[1024*1024*20];
    
25.                         int length = 0 ;
    
26.                         destRaf.seek(index);//设置指针位置
    
27.                        
    
28.                         //读取管道流中的数据，并写入目的文件中
    
29.                         while((length=pis.read(buf))!=-1){
    
30.                                 destRaf.write(buf,0,length);
    
31.                         }
    
32.                         pis.close();
    
33.                         destRaf.close();
    
34.                         System.out.println("over");
    
35.                 } catch (IOException e) {
    
36.                         e.printStackTrace();
    
37.                 }
    
38.         }
    
39. 
    
40. }

复制代码

比起单线程切实是快乐好多倍，但是和电脑自带的比起来，简直就是满满的挫败感。。。
感觉自己当初的懵懂的大志疑惑幻想，是怎么的可笑，如果还有比windows更快更好的，windows一定早就用了吧？
换句话说，windows现在用的岂能不是最好最优的，，，
呵，我也只能带着自己无知无畏最后的无奈匆匆一笑，希望在今后遇到问题能去进一步想想，少一些不切实际幻想，
有想法是好的，关键跟要有这样的实力，敢于幻想，更要能加以辩论！

题外话:我拷贝大文件的时候习惯用fastcopy 可以自定义复制的内存 确实要比windows自带的快得多 windows自带的给的内存才128M

Weidan 发表于 2015-11-29 22:21
题外话:我拷贝大文件的时候习惯用fastcopy 可以自定义复制的内存 确实要比windows自带的快得多 windows自带 ...

谢谢！但是我用的是固态硬盘，不差这点时间
介绍给室友了

参考下别人的高级算法吧。我们的是最基本的算法而已