前言
本文主要介紹的是三種不同的 md5 計算方式，其實區別是讀文件的不同，也就是磁盤 I/O, 所以也可以舉一反三用在網絡 I/O 上。下面來一起看看吧。
ReadFile
先看第一種， 簡單粗暴：
func md5sum1(file string) string { data, err := ioutil.ReadFile(file) if err != nil { return "" } return fmt.Sprintf("%x", md5.Sum(data))}之所以說其粗暴，是因為 ReadFile 里面其實調用了一個 readall， 分配內存是最多的。
Benchmark 來一發：
var test_path = "/path/to/file"func BenchmarkMd5Sum1(b *testing.B) { for i := 0; i < b.N; i++ { md5sum1(test_path) }}go test -test.run=none -test.bench="^BenchmarkMd5Sum1$" -benchtime=10s -benchmemBenchmarkMd5Sum1-4 300 43704982 ns/op 19408224 B/op 14 allocs/opPASSok tmp 17.446s
先說明下，這個文件大小是 19405028 字節，和上面的 19408224 B/op 非常接近, 因為 readall 確實是分配了文件大小的內存，代碼為證：
ReadFile 源碼
// ReadFile reads the file named by filename and returns the contents.// A successful call returns err == nil, not err == EOF. Because ReadFile// reads the whole file, it does not treat an EOF from Read as an error// to be reported.func ReadFile(filename string) ([]byte, error) { f, err := os.Open(filename) if err != nil { return nil, err } defer f.Close() // It's a good but not certain bet that FileInfo will tell us exactly how much to // read, so let's try it but be prepared for the answer to be wrong. var n int64 if fi, err := f.Stat(); err == nil { // Don't preallocate a huge buffer, just in case. if size := fi.Size(); size < 1e9 { n = size } } // As initial capacity for readAll, use n + a little extra in case Size is zero, // and to avoid another allocation after Read has filled the buffer. The readAll // call will read into its allocated internal buffer cheaply. If the size was // wrong, we'll either waste some space off the end or reallocate as needed, but // in the overwhelmingly common case we'll get it just right. // readAll 第二個參數是即將創建的 buffer 大小 return readAll(f, n+bytes.MinRead)}func readAll(r io.Reader, capacity int64) (b []byte, err error) { // 這個 buffer 的大小就是 file size + bytes.MinRead buf := bytes.NewBuffer(make([]byte, 0, capacity)) // If the buffer overflows, we will get bytes.ErrTooLarge. // Return that as an error. Any other panic remains. defer func() { e := recover() if e == nil { return } if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge { err = panicErr } else { panic(e) } }() _, err = buf.ReadFrom(r) return buf.Bytes(), err}io.Copy
再看第二種，
func md5sum2(file string) string { f, err := os.Open(file) if err != nil { return "" } defer f.Close() h := md5.New() _, err = io.Copy(h, f) if err != nil { return "" } return fmt.Sprintf("%x", h.Sum(nil))} 第二種的特點是：使用了 io.Copy。 在一般情況下（特殊情況在下面會提到），io.Copy 每次會分配 32 *1024 字節的內存，即32 KB, 然后咱看下 Benchmark 的情況：
func BenchmarkMd5Sum2(b *testing.B) { for i := 0; i < b.N; i++ { md5sum2(test_path) }}$ go test -test.run=none -test.bench="^BenchmarkMd5Sum2$" -benchtime=10s -benchmemBenchmarkMd5Sum2-4 500 37538305 ns/op 33093 B/op 8 allocs/opPASSok tmp 22.657s
32 * 1024 = 32768, 和 上面的 33093 B/op 很接近。
io.Copy + bufio.Reader
然后再看看第三種情況。
這次不僅用了 io.Copy，還用了 bufio.Reader。 bufio 顧名思義， 即 buffered I/O， 性能相對要好些。bufio.Reader 默認會創建 4096 字節的 buffer。
func md5sum3(file string) string { f, err := os.Open(file) if err != nil { return "" } defer f.Close() r := bufio.NewReader(f) h := md5.New() _, err = io.Copy(h, r) if err != nil { return "" } return fmt.Sprintf("%x", h.Sum(nil))}看下 Benchmark 的情況：
func BenchmarkMd5Sum3(b *testing.B) { for i := 0; i < b.N; i++ { md5sum3(test_path) }}$ go test -test.run=none -test.bench="^BenchmarkMd5Sum3$" -benchtime=10s -benchmemBenchmarkMd5Sum3-4 300 42589812 ns/op 4507 B/op 9 allocs/opPASSok tmp 16.817s
上面的 4507 B/op 是不是和 4096 很接近？ 那為什么 io.Copy + bufio.Reader 的方式所用內存會比單純的 io.Copy 占用內存要少一些呢？ 上文也提到， 一般情況下 io.Copy 每次會分配 32 *1024 字節的內存，那特殊情況是？ 答案在源碼中。
一起看看 io.Copy 相關源碼：
func Copy(dst Writer, src Reader) (written int64, err error) { return copyBuffer(dst, src, nil)}// copyBuffer is the actual implementation of Copy and CopyBuffer.// if buf is nil, one is allocated.func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) { // If the reader has a WriteTo method, use it to do the copy. // Avoids an allocation and a copy. // hash.Hash 這個 Writer 并沒有實現 WriteTo 方法，所以不會走這里 if wt, ok := src.(WriterTo); ok { return wt.WriteTo(dst) } // Similarly, if the writer has a ReadFrom method, use it to do the copy. // 而 bufio.Reader 實現了 ReadFrom 方法，所以，會走這里 if rt, ok := dst.(ReaderFrom); ok { return rt.ReadFrom(src) } if buf == nil { buf = make([]byte, 32*1024) } for { nr, er := src.Read(buf) if nr > 0 { nw, ew := dst.Write(buf[0:nr]) if nw > 0 { written += int64(nw) } if ew != nil { err = ew break } if nr != nw { err = ErrShortWrite break } } if er == EOF { break } if er != nil { err = er break } } return written, err} 從上面的源碼來看， 用 bufio.Reader 實現的 io.Reader 并不會走默認的 buffer創建路徑，而是提前返回了，使用了 bufio.Reader 創建的 buffer, 這也是使用了 bufio.Reader 分配的內存會小一些。
當然如果你希望 io.Copy 也分配小一點的內存，也是可以做到的，不過是用 io.CopyBuffer, buf 就創建一個 4096 的 []byte 即可, 就跟 bufio.Reader 區別不大了。
看看是不是這樣：
// Md5Sum2 用 CopyBufer 重新實現，buf := make([]byte, 4096)BenchmarkMd5Sum2-4 500 38484425 ns/op 4409 B/op 8 allocs/opBenchmarkMd5Sum3-4 500 38671090 ns/op 4505 B/op 9 allocs/op
從結果來看， 分配的內存相差不大，畢竟實現不一樣，不可能一致。
那下次如果你要寫一個下載大文件的程序，你還會用 ioutil.ReadAll(resp.Body) 嗎？
最后整體對比下 Benchmark 的情況：
$ go test -test.run=none -test.bench="." -benchtime=10s -benchmemtesting: warning: no tests to runBenchmarkMd5Sum1-4 300 42551920 ns/op 19408230 B/op 14 allocs/opBenchmarkMd5Sum2-4 500 38445352 ns/op 33089 B/op 8 allocs/opBenchmarkMd5Sum3-4 500 38809429 ns/op 4505 B/op 9 allocs/opPASSok tmp 63.821s
小結
這三種不同的 md5 計算方式在執行時間上都差不多，區別最大的是內存的分配上；
bufio 在處理 I/O 還是很有優勢的，優先選擇；
盡量避免 ReadAll 這種用法。
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作能帶來一定的幫助，如果有疑問大家可以留言交流。
新聞熱點
疑難解答
