脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - 为什么要避免在 Go 中使用 ioutil.ReadAll？

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

2022-01-04 22:40AlwaysBetayongxinz Golang

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

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

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

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

在 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. }
  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)
  13. }

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

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

ioutil.ReadAll 的源码如下：

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

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

  1. // src/io/io.go
  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. }
  22. }

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

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

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

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

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

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

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

io.Copy

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

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

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

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

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

  1. // src/io/io.go
  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
  53. }

此函数执行步骤如下：

如果源实现了 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
  3. import (
  4. "fmt"
  5. "io/ioutil"
  6. )
  8. func main() {
  9. dirName := "../"
  10. fileInfos, _ := ioutil.ReadDir(dirName)
  11. fmt.Println(len(fileInfos))
  12. for i := 0; i < len(fileInfos); i++ {
  13. fmt.Printf("%T\n", fileInfos[i])
  14. fmt.Println(i, fileInfos[i].Name(), fileInfos[i].IsDir())
  16. }
  17. }

ReadFile

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

举例：

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

WriteFile

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

举例：

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

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
  3. import (
  4. "fmt"
  5. "io/ioutil"
  6. "os"
  7. )
  9. func main() {
  10. f, err := ioutil.TempFile("./", "Test")
  11. if err != nil {
  12. fmt.Println(err)
  13. }
  14. defer os.Remove(f.Name()) // 用完删除
  15. fmt.Printf("%s\n", f.Name())
  16. }

TempDir

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

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
  3. import (
  4. "fmt"
  5. "io/ioutil"
  6. "reflect"
  7. "strings"
  8. )
  10. func main() {
  11. //返回 *strings.Reader
  12. reader := strings.NewReader("Hello AlwaysBeta")
  13. r := ioutil.NopCloser(reader)
  14. defer r.Close()
  16. fmt.Println(reflect.TypeOf(reader))
  17. data, _ := ioutil.ReadAll(reader)
  18. fmt.Println(string(data))
  19. }

总结

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

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

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

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

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

源码地址：

https://github.com/yongxinz/gopher

原文地址：https://mp.weixin.qq.com/s/e2A3ME4vhOK2S3hLEJtPsw

  • Go
  • ioutil.ReadAll

    • 延伸 · 阅读

    精彩推荐
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图