md5 大文件

测试 mail.rar , 一个1.59GB 的大文件，结果如下：
// 分别测试3次，下面是测试结果； 我的电脑是 intel i5 4核, 8G 内存； 不运行此程序且 不做任何操作 的时候, 观察发现： cpu 10%, mem 70%
// md5ByJavaIO , 观察发现，大概的平均是： cpu 35%, mem 71%
// md5:8ba6b147475af653bc4609d4cdf72148 time:74s 74s 74s; 测试N多次都是74s， 非常稳定

// md5ByFileChannel , 观察发现，大概的平均是： cpu 31%, mem 71%
// md5:8ba6b147475af653bc4609d4cdf72148 time:75s 72s 73s

// md5ByFileChannelAndMappedByteBuffer , 观察发现，大概的平均是： cpu 30%, mem 71%
// md5:8ba6b147475af653bc4609d4cdf72148 time:52s 53s 54s

// fastMd5 , 观察发现，大概的平均是： cpu 31%, mem 80%
// md5:8ba6b147475af653bc4609d4cdf72148 time:51s 52s 51s

// 实际计算时间的时候， 需要减去休眠的100 * 10， 即1s，

代码如下：

import com.twmacinta.util.MD5;
import com.twmacinta.util.MD5OutputStream;

import java.io.*;

import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

public class MD5Util {
    /**
     * 默认的密码字符串组合，apache校验下载的文件的正确性用的就是默认的这个组合
     */

    protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    protected static MessageDigest messagedigest = null;

    static {
        try {
            messagedigest = MessageDigest.getInstance("MD5");

        } catch (NoSuchAlgorithmException nsaex) {
            System.err.println(MD5Util.class.getName() + "初始化失败，MessageDigest不支持MD5Util。");

            nsaex.printStackTrace();

        }

    }

    public static void main(String[] args) throws IOException {
        long begin = System.currentTimeMillis();

        File big = new File("D:\office2013破解版.ISO"); // 810M
//        big = new File("C:\Users\xd\Desktop\工作重要资料\xxx.zip"); //  2.25G; 但不能超过2G， 否则    at java.base/sun.nio.ch.FileChannelImpl.map(FileChannelImpl.java:994)
        big = new File("D:\lk\mail.rar");// 1.59G

        String md5 = null;

        // 获取文件的 md5； 如果是仅仅是获取字符串的md5， 当然不需要这么复杂。。
        for (int i = 0; i < 10; i++) {
//            md5 = md5ByJavaIO(big); // java io 的方式
//            md5 = md5ByFileChannel(big); // java nio 的方式
//            md5 = md5ByFileChannelAndMappedByteBuffer(big); // fast md5
            md5 = fastMd5(big);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long end = System.currentTimeMillis();

        System.out.println("md5:" + md5 + " time:" + ((end - begin) / 1000) + "s");


        // 分别测试3次，下面是测试结果； 我的电脑是 intel i5 4核, 8G 内存；  不运行此程序且 不做任何操作 的时候, 观察发现： cpu 10%, mem 70%
        // md5ByJavaIO  , 观察发现，大概的平均是： cpu 35%, mem 71%
        // md5:8ba6b147475af653bc4609d4cdf72148 time:74s 74s 74s; 测试N多次都是74s， 非常稳定

        // md5ByFileChannel  , 观察发现，大概的平均是： cpu 31%, mem 71%
        // md5:8ba6b147475af653bc4609d4cdf72148 time:75s  72s  73s

        // md5ByFileChannelAndMappedByteBuffer , 观察发现，大概的平均是： cpu 30%, mem内存几乎毫无增长； ssd是 读300M/S； 写入220K-2M
        // md5:8ba6b147475af653bc4609d4cdf72148 time:52s 53s 54s

        // fastMd5 , 观察发现，大概的平均是： cpu 开始有个高峰，后面趋于平稳，后面是30% ； 大概是80%, mem xxx %
        // md5:8ba6b147475af653bc4609d4cdf72148 time:51s 52s 51s

        // 实际计算时间的时候， 需要减去休眠的100 * 10， 即1s，

    }

    /**
     * 适用于上G大的文件
     *
     * @param file
     * @return
     * @throws IOException
     */

    public static String md5ByFileChannelAndMappedByteBuffer(File file) throws IOException {
        FileInputStream in = new FileInputStream(file);

        FileChannel ch = in.getChannel();

        MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY, 0, file.length());

        messagedigest.update(byteBuffer);

        in.close();

        return bufferToHex(messagedigest.digest());

    }

    private static String md5ByFileChannel(File big) {
        if (big == null) {
            return null;
        }
        MessageDigest md;
        FileInputStream inputStream = null;
        try {
            int read = 0;
            inputStream = new FileInputStream(big);
            md = MessageDigest.getInstance("MD5");
            FileChannel channel = inputStream.getChannel();
            ByteBuffer buff = ByteBuffer.allocate(2048);
            while (channel.read(buff) != -1) {
                buff.flip();
                md.update(buff);
                buff.clear();
            }
            return bufferToHex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            return null;
        } catch (IOException e) {
            return null;
        } finally {
            try {
                if (inputStream != null) inputStream.close();
            } catch (IOException e) {
            }
        }
    }

    //    private String generateMD5(SequenceInputStream inputStream){
    private static String md5ByJavaIO(File big) {
        if (big == null) {
            return null;
        }
        MessageDigest md;
        InputStream inputStream = null;
        try {
            int read = 0;
            inputStream = new FileInputStream(big);
            byte[] buf = new byte[2048];
            md = MessageDigest.getInstance("MD5");
            while ((read = inputStream.read(buf)) > 0) {
                md.update(buf, 0, read);
            }
            return bufferToHex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            return null;
        } catch (IOException e) {
            return null;
        } finally {
            try {
                if (inputStream != null) inputStream.close();
            } catch (IOException e) {
// ...
            }
        }
    }


    private static String fastMd5(File big) {
        String md5Str = null;
        try {
            MD5OutputStream out = new MD5OutputStream(new com.twmacinta.io.NullOutputStream());
            InputStream in = new BufferedInputStream(new FileInputStream(big));
            byte[] buf = new byte[65536];// 65536 是最佳数值， 大于或小于这个数字都会 导致耗时增加， 不知道为什么..
            int num_read;
            long total_read = 0;
            while ((num_read = in.read(buf)) != -1) {
                total_read += num_read;
                out.write(buf, 0, num_read);
            }
            md5Str = MD5.asHex(out.hash());
            //System.out.println(md5Str + "  " + big);
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return md5Str;
    }

    public static String getMD5String(String s) {
        return getMD5String(s.getBytes());
    }

    public static String getMD5String(byte[] bytes) {
        messagedigest.update(bytes);
        return bufferToHex(messagedigest.digest());
    }

    private static String bufferToHex(byte bytes[]) {
        return bufferToHex(bytes, 0, bytes.length);
    }

    private static String bufferToHex(byte bytes[], int m, int n) {
        StringBuffer stringbuffer = new StringBuffer(2 * n);
        int k = m + n;
        for (int l = m; l < k; l++) {
            appendHexPair(bytes[l], stringbuffer);
        }
        return stringbuffer.toString();
    }

    private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
        char c0 = hexDigits[(bt & 0xf0) >> 4];
        char c1 = hexDigits[bt & 0xf];
        stringbuffer.append(c0);
        stringbuffer.append(c1);
    }

    public static boolean checkPassword(String password, String md5PwdStr) {
        String s = getMD5String(password);
        return s.equals(md5PwdStr);
    }

}

可见，大文件的时候， 最好还是不要java IO到内存， 可能映射过程就需要比较久时间。NIO MPP是很好的选择。

另外， 我们是否可以继续提高 大文件md5 的计算速度呢？ 据说 多线程分块校验。。

我感觉 行得通，MD5算法本身是分块的，其他很多类似的算法比如SHA-1也是的，所以可以支持流式计算，读一块算一块，最后再一次性生成完整hash，完全没有内存爆炸的可能。  除非 算法本身不支持这样做。

我们之前也使用过这样的做法， 就是取每100m的前1m作md5.然后整体再md5一次。但是我感觉不太安全， 也就是说不准确。虽然呢时间少花了很多，但恐怕是容易发生碰撞

最后，我这边使用了一个 fastMD5的java 库， 发现确实可以稍微提升一点速度。 fastMD5 主要作用，大概是 不要NIO, 直接普通FIleInputStream 即可， 但是呢， 使用FIleInputStream 文件最大是2G 。

 

确实， 现在前端也可以很快完成md5 计算！

补充前端计算的方法，webuploader 支持分片计算md5，设置的分片不要太大就好了。