java 多线程文件复制

目标是用多线程实现文件读取和写入，但是，实际却发现，java的io并不允许多线程同时写入，读取可以，本来想要 写个比操作系统快的复制功能，代码只实现了基本版本，还有缺陷，以后会继续完善，如果大家有更快速写入文件的方法，一定要留言哦

在目前没有多线程写入的前提下，读取后写入队列然后再起一个线程写文件会比现在的代码要快，但是也不是我想要的并发写入，大家有没有更好的解决方案。nio中的FileChannel.transferTo，经过测试，写入也是阻塞其他线程的

 

import java.io.File;
import java.io.FileInputStream;
import java.math.BigInteger;
import java.security.MessageDigest;

public class Digest {
    public static String getFileMD5(File file) {
        if (!file.isFile()) {
            return null;
        }
        MessageDigest digest = null;
        FileInputStream in = null;
        byte buffer[] = new byte[8192];
        int len;
        try {
            digest = MessageDigest.getInstance("MD5");
            in = new FileInputStream(file);
            while ((len = in.read(buffer)) != -1) {
                digest.update(buffer, 0, len);
            }
            BigInteger bigInt = new BigInteger(1, digest.digest());
            return bigInt.toString(16);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                in.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static String getFileSha1(File file) {
        if (!file.isFile()) {
            return null;
        }
        MessageDigest digest = null;
        FileInputStream in = null;
        byte buffer[] = new byte[8192];
        int len;
        try {
            digest = MessageDigest.getInstance("SHA-1");
            in = new FileInputStream(file);
            while ((len = in.read(buffer)) != -1) {
                digest.update(buffer, 0, len);
            }
            BigInteger bigInt = new BigInteger(1, digest.digest());
            return bigInt.toString(16);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                in.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

 

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.text.DecimalFormat;

public class CopyFile {

    private String fileName = "";
    private int buffSize = 1024;
    private long fileSize = 0;
    private int threadNum = 2;
    private String newName = "";
    private String newPath = "";
    private String copyIn = "";
    private boolean showProgress = true;
    private boolean end = false;
    long stime = 0;
    long etime = 0;
    private long copySize = 0;
    private File srcfile = null;
    File newFile = null;
    File filecopyIn = null;

    public CopyFile(String filePath) {
        this.fileName = filePath;
    }

    public CopyFile(String filePath, int threadNum) {
        this.fileName = filePath;
        this.threadNum = threadNum;
    }

    public CopyFile(String filePath, int threadNum, int buffSize) {
        this.fileName = filePath;
        this.buffSize = buffSize;
        this.threadNum = threadNum;
    }

    public void to() throws IOException {
        if (newPath == null || "".equals(newPath)) {
            newPath = new File(fileName).getParent();
            to(newPath);
        }
    }

    public void to(String newPath) throws IOException {
        if (!new File(newPath).isDirectory()) {
            throw new IOException("目标必须为目录");
        }
        srcfile = new File(fileName);
        stime = System.currentTimeMillis();
        this.newName = newFileName(newPath, fileName);
        copyIn = newName + ".copyIN";
        newFile = new File(newName);
        if (newFile.exists()) {
            newFile.delete();
        }
        filecopyIn = new File(copyIn);
        if (filecopyIn.exists()) {
            filecopyIn.delete();
        }

        InputStream in = new FileInputStream(srcfile);
        fileSize = in.available();
        for (int i = 0; i < threadNum; i++) {
            long s = fileSize / threadNum * i;
            long e = fileSize / threadNum * (i + 1)
                    + (i == threadNum - 1 ? fileSize % threadNum : 0);
            new copyThread(s, e);
        }
        if (showProgress)
            new Progress().start();

    }

    private String newFileName(String newPath2, String fileName2) {
        String tmp = srcfile.getName();
        int suffixIndex = tmp.lastIndexOf(".");
        if (suffixIndex > -1) {
            tmp = tmp.substring(0, suffixIndex) + " copy"
                    + tmp.substring(suffixIndex, tmp.length());
        } else {
            tmp += " copy";
        }
        if (!newPath2.endsWith(File.separatorChar + ""))
            newPath2 += File.separatorChar;
        return newPath2 + tmp;
    }

    public long end() {
        long newFileLength = 0;
        if (filecopyIn.renameTo(newFile)) {
            newFileLength = newFile.length();
        } else {
            System.out.println("重命名失败");
            newFileLength = filecopyIn.length();
        }
        long time = System.currentTimeMillis();
        etime = time;
        long haoshi = (etime - stime);
        System.out.println("用时=" + haoshi + "毫秒");
        System.out.println("源文件:" + fileSize + "   复制的文件:" + newFileLength
                + "   丢失:" + (fileSize - newFileLength));
        System.out
                .println("文件:"
                        + Digest.getFileMD5(srcfile).equals(
                                Digest.getFileMD5(newFile)));
        end = true;
        return haoshi;
    }

    class Progress extends Thread {
        public void run() {
            DecimalFormat df = new DecimalFormat("0");
            while (!end) {
                long progress = Integer.parseInt(df.format((float) copySize
                        / fileSize * 100));
                System.out.println(progress + "%");
                if (progress == 100)
                    end();
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class copyThread extends Thread {
        private RandomAccessFile in = null;
        private RandomAccessFile out = null;
        private long startOff = 0, endOff = 0;
        private byte[] buff;

        public copyThread(long startOff, long endOff) {
            try {
                this.startOff = startOff;
                this.endOff = endOff;
                in = new RandomAccessFile(fileName, "r");
                in.seek(startOff);
                out = new RandomAccessFile(copyIn, "rwd");
                out.seek(startOff);
                start();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public void run() {
            try {
                System.out.println("start=" + startOff + "  end=" + endOff);
                buff = new byte[buffSize];
                long currentThreadTotal = endOff - startOff;
                long yu = currentThreadTotal % buffSize;
                int off = buffSize;
                long forCount = currentThreadTotal / buffSize
                        + (yu > 0 ? 1 : 0);
                for (long i = 0; i < forCount; i++) {
                    off = (int) (i == forCount - 1 && yu > 0 ? yu : buffSize);
                    int rd = in.read(buff, 0, off);
                    if (rd != -1)
                        out.write(buff, 0, rd);
                    if (showProgress) {
                        synchronized (this) {
                            copySize += rd;
                        }
                    }
                    yield();
                }

                in.close();
                out.close();
                // end();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        String y = "e:/baidu download/贫民窟的百万富翁.rmvb";
        String n = "e:/baidu download/";
        CopyFile cf = new CopyFile(y, 3, 1024 * 1024 * 10);
        try {
            cf.to();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}