1. 引言

當我們需要將資料一次性加載到記憶體中，ioutil.ReadAll 函式是一個方便的選擇，但是ioutil.ReadAll 的使用是需要注意的，

在這篇文章中，我們將首先對ioutil.ReadAll函式進行基本介紹，之后會介紹其存在的問題，以及引起該問題的原因，最后給出了ioutil.ReadAll 函式的替代操作，通過這些內容，希望能幫助你更好地理解和使用ioutil.ReadAll 函式，

2. 基本說明

ioutil.ReadAll其實是標準庫的一個函式，其作用是從Reader 引數讀取所有的資料，直到遇到EOF為止，函式定義如下:

func ReadAll(r io.Reader) ([]byte, error)

其中r 為待讀取資料的Reader，資料讀取結果將以位元組切片的形式來回傳，如果讀取程序中遇到了錯誤，也會回傳對應的錯誤，

下面通過一個簡單的示例，來簡單說明ioutil.ReadAll 函式的使用:

package main

import (
        "fmt"
        "io/ioutil"
        "os"
)

func main() {
        filePath := "example.txt"

        // 打開檔案
        file, err := os.Open(filePath)
        if err != nil {
              fmt.Println("無法打開檔案：%s", err)
              return
        }
        defer file.Close()

        // 讀取檔案全部資料
        data, err := ioutil.ReadAll(file)
        if err != nil {
                fmt.Println("無法讀取檔案：%s", err)
                return
        }

        // 將讀取到的資料轉換為字串并輸出
        content := string(data)
        fmt.Println("檔案內容：")
        fmt.Println(content)
}

在這個示例中，我們使用os.Open 函式打開指定路徑的檔案，獲取到一個os.File 物件，接著，呼叫 ioutil.ReadAll 便能讀取到檔案的全部資料，

3. 為什么使用 ioutil.ReadAll 需要注意

從上面的基本說明我們可以得知，ioutil.ReadAll 的作用是讀取指定資料源的全部資料，并將其以位元組陣列的形式來回傳，比如，我們想要將整個檔案的資料加載到記憶體中，此時就可以使用 ioutil.ReadAll 函式來實作，

那這里就有一個問題，加載一份資料到記憶體中，會耗費多少記憶體資源呢? 按照我們的理解，正常是資料源資料有多大，就大概消耗多大的記憶體資源，

然而，如果使用 ioutil.ReadAll 函式加載資料時消耗的記憶體資源，可能與我們的想法存在一些差距，通常使用 ioutil.ReadAll 函式加載全部資料有可能會消耗更多的記憶體，

下面我們創建一個10M的檔案，然后寫一個基準測驗函式，來展示使用 ioutil.ReadAll 加載整個檔案的資料，需要分配多少記憶體，函式如下:

func BenchmarkReadAllMemoryUsage(b *testing.B) {
   filePath := "largefile.txt"

   for n := 0; n < b.N; n++ {
      // 打開檔案
      file, err := os.Open(filePath)
      if err != nil {
         fmt.Println("無法打開檔案：%r", err)
         return
      }
      defer file.Close()
      _, err = ioutil.ReadAll(file)
      if err != nil {
         b.Fatal(err)
      }
   }
}

基準測驗的運行結果如下:

BenchmarkReadAllMemoryUsage-4                106          14385391 ns/op        52263424 B/op         42 allocs/op

其中106，表示基準測驗的迭代次數，14385391 ns/op, 表示每次迭代的平均執行時間，52263424 B/op表示每次迭代的平均記憶體分配量，42 allocs/op 表示每次迭代的平均分配次數，

上面基準測驗的結果，我們主要關注每次迭代需要消耗的記憶體量，也就是 52263424 B/op 這個資料，這個大概相當于50M左右，在這個示例中，我們使用 ioutil.ReadAll 加載一個10M大小的檔案，此時需要分配50M的記憶體，是檔案大小的5倍，

從這里我們可以看出，使用ioutil.ReadAll 加載資料時，存在的一個注意點，便是其分配的記憶體遠遠大于待加載資料的大小，

那我們就有疑問了，為什么 ioutil.ReadAll 加載資料時，會消耗這么多記憶體呢? 下面我們通過說明ioutil.ReadAll 函式的實作，來解釋其中的原因，

4. 為什么這么消耗記憶體

ioutil.ReadAll 函式的實作其實比較簡單，ReadAll 函式會初始化一個位元組切片緩沖區，然后呼叫源Reader 的Read 方法不斷讀取資料，直接讀取到EOF 為止，

不過需要注意的是，ReadAll 函式初始化的緩沖區，其初始化大小只有512個位元組，在讀取程序中，如果緩沖區長度不夠，將會不斷擴容該緩沖區，直到緩沖區能夠容納所有待讀取資料為止，所以呼叫ioutil.ReadAll 可能會存在多次記憶體分配的現象，下面我們來看其代碼實作:

func ReadAll(r Reader) ([]byte, error) {
   // 初始化一個 512 個位元組長度的 位元組切片
   b := make([]byte, 0, 512)
   for {
      // len(b) == cap(b),此時緩沖區已滿，需要擴容
      if len(b) == cap(b) {
         // 首先append(b,0), 觸發切片的擴容機制
         // 然后再去掉前面 append 的 '0' 字符
         b = append(b, 0)[:len(b)]
      }
      // 呼叫Read 方法讀取資料
      n, err := r.Read(b[len(b):cap(b)])
      // 更新切片 len 欄位的值
      b = b[:len(b)+n]
      if err != nil {
         // 讀取到 EOF, 此時直接回傳
         if err == EOF {
            err = nil
         }
         return b, err
      }
   }
}

從上面代碼實作來看，使用 ioutil.ReadAll 加載資料需要分配大量記憶體的原因是因為切片的不斷擴容導致的，

ioutil.ReadAll 加載資料時，一開始只初始化了一個512位元組大小的切片，如果待加載的資料超過512位元組的話，切片會觸發擴容操作，同時其也不是一次性擴容到能夠容納所有資料的長度，而是基于切片的擴容機制來決定的，接下來可能會擴容到1024個位元組，會重新申請一塊記憶體空間，然后將原切片資料拷貝過去，

之后如果資料超過1024個位元組，切片會繼續擴容的操作，如此反復，直到切片能夠容納所有的資料為止，這個程序中會存在多次的記憶體分配的操作，導致大量記憶體的消耗，

因此，當使用 ioutil.ReadAll加載資料時，記憶體消耗會隨著資料的大小而增加，特別是在處理大檔案或大資料集時，可能需要分配大量的記憶體空間，這就解釋了為什么僅加載一個10M大小的檔案，就需要分配50M記憶體的現象，

5. 替換操作

既然 ioutil.ReadAll 這么消耗記憶體，那么我們應該盡量避免對其進行使用，但是有時候，我們又需要讀取全部資料到記憶體中，這個時候其實可以使用其他函式來替代ioutil.ReadAll，下面從檔案讀取和網路IO讀取這兩個方面來進行介紹，

5.1 檔案讀取

ioutil 工具包中，還存在一個ReadFile的工具函式，能夠加載檔案的全部資料到記憶體中，函式定義如下:

func ReadFile(filename string) ([]byte, error) {}

ReadFile函式的使用非常簡單，只需要傳入一個待加載檔案的路徑，回傳的資料為檔案的內容，下面通過一個基準函式，展示其加載檔案時需要的分配記憶體數等的資料，來和ioutil.ReadAll做一個比較:

func BenchmarkReadFileMemoryUsage(b *testing.B) {
   filePath := "largefile.txt"
   for n := 0; n < b.N; n++ {
      _, err := ioutil.ReadFile(filePath)
      if err != nil {
         b.Fatal(err)
      }
   }
}

上面基準測驗運行結果如下:

// ReadFile 函式基準測驗結果
BenchmarkReadFileMemoryUsage-4                592           1942212 ns/op        10494290 B/op          5 allocs/op
// ReadAll 函式基準測驗結果
BenchmarkReadAllMemoryUsage-4                106          14385391 ns/op        52263424 B/op         42 allocs/op

使用ReadFile加載整個檔案的資料，分配的記憶體數大概也為10M左右，同時執行時間和記憶體分配次數，也相對于ReadAll 函式來看，也相對更小，

因此，如果我們確實需要加載檔案的全部資料，此時使用ReadFile相對于ReadAll 肯定是更為合適的，

5.2 網路IO讀取

如果是網路IO操作，此時我們需要假定一個前提，是所有的回應資料，應該都是有回應頭的，能夠通過回應頭，獲取到回應體的長度，然后再基于此讀取全部回應體的資料，

這里可以使用io.Copy函式來將資料拷貝，從而來替代ioutil.ReadAll，下面是一個大概代碼結構:

package main

import (
        "bytes"
        "fmt"
        "io"
        "os"
)

func main() {
        // 1. 建立一個網路連接
        src := xxx
        defer src.Close()
        // 2. 讀取報文頭,獲取請求包的長度
        size := xxx
        // 3. 基于該 size 創建一個 位元組切片
        buf := make([]byte, size)
        buffer := bytes.NewBuffer(buf)
        // 4. 使用buffer來讀取資料
        _, err = io.Copy(&buffer, srcFile)
        if err != nil {
                fmt.Println("Failed to copy data:", err)
                return
        }
        // 現在資料已加載到記憶體中的緩沖區（buffer）中
        fmt.Println("Data loaded into buffer successfully.")
}

通過這種方式，能夠使用io.Copy 函式替換ioutil.ReadAll ，讀取到所有的資料，而io.Copy 函式不會存在 ioutil.ReadAll 函式存在的問題，

6. 總結

本文首先對 ioutil.ReadAll 進行了基本的說明，同時給了一個簡單的使用示例，

隨后，通過基準測驗展示了使用 ioutil.ReadAll 加載資料，消耗的記憶體可能遠遠大于待加載的資料，之后，通過對原始碼講解，說明了導致這個現象導致的原因，

最后，給出了一些替代方案，如使用 ioutil.ReadFile 函式和使用 io.Copy 函式等，以減少記憶體占用，基于以上內容，便完成了對ioutil.ReadAll 函式的介紹，希望對你有所幫助，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/556997.html

標籤：其他

上一篇：為什么使用ioutil.ReadAll 函式需要注意

下一篇：返回列表