有些开发的时候我们经常遇到这样一个问题，对大文件的处理。比如：日志文件。那么十几G的大文件。我们应该如何复制呢？

还有就是希望从本地和远程复制文件，文件都很大，10G级的如何办呢？

在这里我告诉你们，可以用java多线程实现复制。

原理：就是多线程把大文件分成小文件，实现快速复制。

下面直接看代码：

package com.huojg.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;

/**
 * java用线程实现复制文件：就是复制大文件时，用多个线程把大文件分成小文件，实现快速复制
 * 
 * 
 * */
public class CopyFile implements Runnable{

    @Override
    public synchronized  void run() {
        InputStream is;
        try {
            is = new FileInputStream("f:"+File.separator+"file1"+File.separator+"321.txt");
            Reader rd=new InputStreamReader(is,"gbk");
            BufferedReader br=new BufferedReader(rd);
            OutputStream os=
                    new FileOutputStream("f:"+File.separator+"file1"+File.separator+"1234.txt");
            OutputStreamWriter osw=new OutputStreamWriter(os,"gbk");
            String str="";
            while((str=br.readLine())!=null){
                osw.write(str);
                System.out.println(str);
            }
            osw.close();
            br.close();
            os.close();
            rd.close();
            is.close();
            System.out.println(Thread.currentThread().getName()+"：复制完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试类;

package com.huojg.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CopyFileText {
    public static void main(String[] args) {
        CopyFile cf=new CopyFile();
        ExecutorService es= Executors.newFixedThreadPool(3);
        es.execute(cf);
        es.execute(cf);
        es.execute(cf);    
        es.shutdown();
    }
}

这样子我们的多线程就完成了。

下面说一下线程池：

3、在使用线程池之前，必须知道如何去创建一个线程池，在Java5中，需要了解java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的。 

一、固定大小的线程池，newFixedThreadPool：

1. 创建一个可重用固定线程数的线程池  
2. ExecutorService pool = Executors.newFixedThreadPool(5); 
3. 然后将线程放入池中进行执行  
4. 关闭线程池  pool.shutdown();

二、单任务线程池，newSingleThreadExecutor： 

每次调用execute方法，其实最后都是调用了thread-1的run方法。

三、可变尺寸的线程池，newCachedThreadPool：

这种方式的特点是：可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

四、延迟连接池，newScheduledThreadPool：

 // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。  
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);  
        // 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口  
        Thread t1 = new MyThread();  
        Thread t2 = new MyThread();  
        Thread t3 = new MyThread();  
        // 将线程放入池中进行执行  
        pool.execute(t1);  
        // 使用延迟执行风格的方法  
        pool.schedule(t2, 1000, TimeUnit.MILLISECONDS);  
        pool.schedule(t3, 10, TimeUnit.MILLISECONDS);  
  
        // 关闭线程池  
        pool.shutdown();  

ExecutorService：是一个接口，继承了Executor: Executor：而Executor亦是一个接口，该接口只包含了一个方法：

void execute(Runnable command);

newFixedThreadPool()

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程