为什么要避免在 Go 中使用 ioutil.ReadAll?

开发 前端
本篇文章从一个问题入手,重点研究了 ioutil.ReadAll 函数。主要原因是在小数据量的情况下,这个函数并没有什么问题,但当数据量大时,它就变成了一颗定时炸弹。有可能会影响程序的性能,甚至会导致程序崩溃。

ioutil.ReadAll 主要的作用是从一个 io.Reader 中读取所有数据,直到结尾。

在 GitHub 上搜索 ioutil.ReadAll,类型选择 Code,语言选择 Go,一共得到了 637307 条结果。

这说明 ioutil.ReadAll 还是挺受欢迎的,主要也是用起来确实方便。

但是当遇到大文件时,这个函数就会暴露出两个明显的缺点:

性能问题,文件越大,性能越差。

文件过大的话,可能直接撑爆内存,导致程序崩溃。

为什么会这样呢?这篇文章就通过源码来分析背后的原因,并试图给出更好的解决方案。

下面我们正式开始。

ioutil.ReadAll

首先,我们通过一个例子看一下 ioutil.ReadAll 的使用场景。比如说,使用 http.Client 发送 GET 请求,然后再读取返回内容:

  1. func main() { 
  2.     res, err := http.Get("http://www.google.com/robots.txt"
  3.     if err != nil { 
  4.         log.Fatal(err) 
  5.     } 
  6.  
  7.     robots, err := io.ReadAll(res.Body) 
  8.     res.Body.Close() 
  9.     if err != nil { 
  10.         log.Fatal(err) 
  11.     } 
  12.     fmt.Printf("%s", robots) 

http.Get() 返回的数据,存储在 res.Body 中,通过 ioutil.ReadAll 将其读取出来。

表面上看这段代码没有什么问题,但仔细分析却并非如此。想要探究其背后的原因,就只能靠源码说话。

ioutil.ReadAll 的源码如下:

  1. // src/io/ioutil/ioutil.go 
  2.  
  3. func ReadAll(r io.Reader) ([]byte, error) { 
  4.     return io.ReadAll(r) 

Go 1.16 版本开始,直接调用 io.ReadAll() 函数,下面再看看 io.ReadAll() 的实现:

  1. // src/io/io.go 
  2.  
  3. func ReadAll(r Reader) ([]byte, error) { 
  4.     // 创建一个 512 字节的 buf 
  5.     b := make([]byte, 0, 512) 
  6.     for { 
  7.         if len(b) == cap(b) { 
  8.             // 如果 buf 满了,则追加一个元素,使其重新分配内存 
  9.             b = append(b, 0)[:len(b)] 
  10.         } 
  11.         // 读取内容到 buf 
  12.         n, err := r.Read(b[len(b):cap(b)]) 
  13.         b = b[:len(b)+n] 
  14.         // 遇到结尾或者报错则返回 
  15.         if err != nil { 
  16.             if err == EOF { 
  17.                 err = nil 
  18.             } 
  19.             return b, err 
  20.         } 
  21.     } 

我给代码加上了必要的注释,这段代码的执行主要分三个步骤:

  • 创建一个 512 字节的 buf;
  • 不断读取内容到 buf,当 buf 满的时候,会追加一个元素,促使其重新分配内存;
  • 直到结尾或报错,则返回;

知道了执行步骤,但想要分析其性能问题,还需要了解 Go 切片的扩容策略,如下:

  • 如果期望容量大于当前容量的两倍就会使用期望容量;
  • 如果当前切片的长度小于 1024 就会将容量翻倍;
  • 如果当前切片的长度大于 1024 就会每次增加 25% 的容量,直到新容量大于期望容量;

也就是说,如果待拷贝数据的容量小于 512 字节的话,性能不受影响。但如果超过 512 字节,就会开始切片扩容。数据量越大,扩容越频繁,性能受影响越大。

如果数据量足够大的话,内存可能就直接撑爆了,这样的话影响就大了。

那有更好的替换方案吗?当然是有的,我们接着往下看。

io.Copy

可以使用 io.Copy 函数来代替,源码定义如下:

  1. src/io/io.go 
  2.  
  3. func Copy(dst Writer, src Reader) (written int64, err error) { 
  4.     return copyBuffer(dst, src, nil) 

其功能是直接从 src 读取数据,并写入到 dst。

和 ioutil.ReadAll 最大的不同就是没有把所有数据一次性都取出来,而是不断读取,不断写入。

具体实现 Copy 的逻辑在 copyBuffer 函数中实现:

  1. // src/io/io.go 
  2.  
  3. func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) { 
  4.     // 如果源实现了 WriteTo 方法,则直接调用 WriteTo 
  5.     if wt, ok := src.(WriterTo); ok { 
  6.         return wt.WriteTo(dst) 
  7.     } 
  8.     // 同样的,如果目标实现了 ReaderFrom 方法,则直接调用 ReaderFrom 
  9.     if rt, ok := dst.(ReaderFrom); ok { 
  10.         return rt.ReadFrom(src) 
  11.     } 
  12.     // 如果 buf 为空,则创建 32KB 的 buf 
  13.     if buf == nil { 
  14.         size := 32 * 1024 
  15.         if l, ok := src.(*LimitedReader); ok && int64(size) > l.N { 
  16.             if l.N < 1 { 
  17.                 size = 1 
  18.             } else { 
  19.                 size = int(l.N) 
  20.             } 
  21.         } 
  22.         buf = make([]byte, size
  23.     } 
  24.     // 循环读取数据并写入 
  25.     for { 
  26.         nr, er := src.Read(buf) 
  27.         if nr > 0 { 
  28.             nw, ew := dst.Write(buf[0:nr]) 
  29.             if nw < 0 || nr < nw { 
  30.                 nw = 0 
  31.                 if ew == nil { 
  32.                     ew = errInvalidWrite 
  33.                 } 
  34.             } 
  35.             written += int64(nw) 
  36.             if ew != nil { 
  37.                 err = ew 
  38.                 break 
  39.             } 
  40.             if nr != nw { 
  41.                 err = ErrShortWrite 
  42.                 break 
  43.             } 
  44.         } 
  45.         if er != nil { 
  46.             if er != EOF { 
  47.                 err = er 
  48.             } 
  49.             break 
  50.         } 
  51.     } 
  52.     return written, err 

此函数执行步骤如下:

如果源实现了 WriteTo 方法,则直接调用 WriteTo 方法;

同样的,如果目标实现了 ReaderFrom 方法,则直接调用 ReaderFrom 方法;

如果 buf 为空,则创建 32KB 的 buf;

最后就是循环 Read 和 Write;

对比之后就会发现,io.Copy 函数不会一次性读取全部数据,也不会频繁进行切片扩容,显然在数据量大时是更好的选择。

ioutil 其他函数

再看看 ioutil 包的其他函数:

  • func ReadDir(dirname string) ([]os.FileInfo, error)
  • func ReadFile(filename string) ([]byte, error)
  • func WriteFile(filename string, data []byte, perm os.FileMode) error
  • func TempFile(dir, prefix string) (f *os.File, err error)
  • func TempDir(dir, prefix string) (name string, err error)
  • func NopCloser(r io.Reader) io.ReadCloser

下面举例详细说明:

ReadDir

  1. // ReadDir 读取指定目录中的所有目录和文件(不包括子目录)。 
  2. // 返回读取到的文件信息列表和遇到的错误,列表是经过排序的。 
  3. func ReadDir(dirname string) ([]os.FileInfo, error) 

举例:

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "io/ioutil" 
  6.  
  7. func main() { 
  8.     dirName := "../" 
  9.     fileInfos, _ := ioutil.ReadDir(dirName) 
  10.     fmt.Println(len(fileInfos)) 
  11.     for i := 0; i < len(fileInfos); i++ { 
  12.         fmt.Printf("%T\n", fileInfos[i]) 
  13.         fmt.Println(i, fileInfos[i].Name(), fileInfos[i].IsDir()) 
  14.  
  15.     } 

ReadFile

  1. // ReadFile 读取文件中的所有数据,返回读取的数据和遇到的错误 
  2. // 如果读取成功,则 err 返回 nil,而不是 EOF 
  3. func ReadFile(filename string) ([]byte, error) 

举例:

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "io/ioutil" 
  6.     "os" 
  7.  
  8. func main() { 
  9.     data, err := ioutil.ReadFile("./test.txt"
  10.     if err != nil { 
  11.         fmt.Println("read error"
  12.         os.Exit(1) 
  13.     } 
  14.     fmt.Println(string(data)) 

WriteFile

  1. // WriteFile 向文件中写入数据,写入前会清空文件。 
  2. // 如果文件不存在,则会以指定的权限创建该文件。 
  3. // 返回遇到的错误。 
  4. func WriteFile(filename string, data []byte, perm os.FileMode) error 

举例:

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "io/ioutil" 
  6.  
  7. func main() { 
  8.     fileName := "./text.txt" 
  9.     s := "Hello AlwaysBeta" 
  10.     err := ioutil.WriteFile(fileName, []byte(s), 0777) 
  11.     fmt.Println(err) 

TempFile

  1. // TempFile 在 dir 目录中创建一个以 prefix 为前缀的临时文件,并将其以读 
  2. // 写模式打开。返回创建的文件对象和遇到的错误。 
  3. // 如果 dir 为空,则在默认的临时目录中创建文件(参见 os.TempDir),多次 
  4. // 调用会创建不同的临时文件,调用者可以通过 f.Name() 获取文件的完整路径。 
  5. // 调用本函数所创建的临时文件,应该由调用者自己删除。 
  6. func TempFile(dir, prefix string) (f *os.File, err error) 

举例:

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "io/ioutil" 
  6.     "os" 
  7.  
  8. func main() { 
  9.     f, err := ioutil.TempFile("./""Test"
  10.     if err != nil { 
  11.         fmt.Println(err) 
  12.     } 
  13.     defer os.Remove(f.Name()) // 用完删除 
  14.     fmt.Printf("%s\n", f.Name()) 

TempDir

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "io/ioutil" 
  6.     "os" 
  7.  
  8. func main() { 
  9.     dir, err := ioutil.TempDir("./""Test"
  10.     if err != nil { 
  11.         fmt.Println(err) 
  12.     } 
  13.     defer os.Remove(dir) // 用完删除 
  14.     fmt.Printf("%s\n", dir) 

NopCloser

  1. // NopCloser 将 r 包装为一个 ReadCloser 类型,但 Close 方法不做任何事情。 
  2. func NopCloser(r io.Reader) io.ReadCloser 

这个函数的使用场景是这样的:

有时候我们需要传递一个 io.ReadCloser 的实例,而我们现在有一个 io.Reader 的实例,比如:strings.Reader。

这个时候 NopCloser 就派上用场了。它包装一个 io.Reader,返回一个 io.ReadCloser,相应的 Close 方法啥也不做,只是返回 nil。

举例:

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "io/ioutil" 
  6.     "reflect" 
  7.     "strings" 
  8.  
  9. func main() { 
  10.     //返回 *strings.Reader 
  11.     reader := strings.NewReader("Hello AlwaysBeta"
  12.     r := ioutil.NopCloser(reader) 
  13.     defer r.Close() 
  14.  
  15.     fmt.Println(reflect.TypeOf(reader)) 
  16.     data, _ := ioutil.ReadAll(reader) 
  17.     fmt.Println(string(data)) 

总结

ioutil 提供了几个很实用的工具函数,背后实现逻辑也并不复杂。

本篇文章从一个问题入手,重点研究了 ioutil.ReadAll 函数。主要原因是在小数据量的情况下,这个函数并没有什么问题,但当数据量大时,它就变成了一颗定时炸弹。有可能会影响程序的性能,甚至会导致程序崩溃。

接下来给出对应的解决方案,在数据量大的情况下,最好使用 io.Copy 函数。

文章最后继续介绍了 ioutil 的其他几个函数,并给出了程序示例。相关代码都会上传到 GitHub,需要的同学可以自行下载。

好了,本文就到这里吧。关注我,带你通过问题读 Go 源码。

源码地址:

https://github.com/yongxinz/gopher

 

责任编辑:武晓燕 来源: AlwaysBeta
相关推荐

2022-12-26 00:25:06

2021-04-26 09:33:46

Go Iota语言

2023-11-27 19:39:46

Goprotobuf

2022-06-02 08:48:39

Go枚举器Iota

2022-01-17 16:09:43

Go语言开发

2021-10-13 14:06:46

MySQLUtf8符号

2021-11-29 22:59:34

Go Dockertest集成

2023-10-28 16:22:21

Go接口

2020-05-25 15:37:47

物联网设备密码物联网安全

2022-06-30 08:03:13

Prisma数据库工具开源

2023-01-11 08:06:42

对象赋值项目开发

2016-03-24 09:53:24

swiftguardios

2020-02-24 09:38:05

PythonGo语言Linux

2020-06-22 07:18:21

Java语言开发

2023-11-30 09:00:00

TypeScript开发

2024-01-02 10:38:22

Go语言数组

2013-07-29 14:50:43

API

2021-06-17 06:19:20

存储SQL数据库

2015-05-25 15:31:56

C语言学习和使用 C 语言

2024-03-25 10:00:00

C++编程else
点赞
收藏

51CTO技术栈公众号