一文了解 io.Copy 函数

淡淡的烟草味﹌ 2024-03-17 18:44 5阅读 0赞

## 1. 引言 ##

`io.Copy` 函数是一个非常好用的函数，能够非常方便得将数据进行拷贝。本文我们将从`io.Copy` 函数的基本定义出发，讲述其基本使用和实现原理，以及一些注意事项，基于此完成对`io.Copy` 函数的介绍。

## 2. 基本说明 ##

#### 2.1 基本定义 ####

`Copy`函数用于将数据从源（`io.Reader`）复制到目标（`io.Writer`）。它会持续复制直到源中的数据全部读取完毕或发生错误，并返回复制的字节数和可能的错误。函数定义如下:

func Copy(dst io.Writer, src io.Reader) (written int64, err error)

其中`dst` 为目标写入器，用于接收源数据；`src`则是源读取器，用于提供数据。

#### 2.2 使用示例 ####

下面提供一个使用 `io.Copy` 实现数据拷贝的代码示例，比便更好得理解和使用`Copy`函数，代码示例如下:

package main
    
    import (
            "fmt"
            "io"
            "os"
    )
    
    func main() {
            fmt.Print("请输入一个字符串：")
            src := readString()
            // 通过io.Copy 函数能够将 src 的全部数据 拷贝到 控制台上输出
            written, err := io.Copy(os.Stdout, src)
            if err != nil {
                    fmt.Println("复制过程中发生错误：", err)
                    return
            }
    
            fmt.Printf("\n成功复制了 %d 个字节。\n", written)
    }
    
    func readString() io.Reader {
       buffer := make([]byte, 1024)
       n, _ := os.Stdin.Read(buffer)
       // 如果实际读取的字节数少于切片长度，则截取切片
       if n < len(buffer) {
          buffer = buffer[:n]
       }
       return strings.NewReader(string(buffer))
    }

在这个例子中，我们首先使用`readString`函数从标准输入中读取字符串，然后使用`strings.NewReader`将其包装为`io.Reader`返回。

然后，我们调用`io.Copy`函数，将读取到数据全部复制到标准输出（`os.Stdout`）。最后，我们打印复制的字节数。可以运行这个程序并在终端输入一个字符串，通过`Copy`函数，程序最终会将字符串打印到终端上。

## 3. 实现原理 ##

在了解了`io.Copy` 函数的基本定义和使用后，这里我们来对 `io.Copy` 函数的实现来进行基本的说明，加深对 `io.Copy` 函数的理解。

`io.Copy`基本实现原理如下，首先创建一个缓冲区，用于暂存从源Reader读取到的数据。然后进入一个循环，每次循环从源Reader读取数据，然后存储到之前创建的缓冲区，之后再写入到目标Writer中。不断重复这个过程，直到源Reader返回EOF，此时代表数据已经全部读取完成，`io.Copy`也完成了从源Reader往目标Writer拷贝全部数据的工作。

在这个过程中，如果往目标`Writer`写入数据过程中发生错误，亦或者从源`Reader`读取数据发生错误，此时`io.Copy`函数将会中断，然后返回对应的错误。下面我们来看`io.Copy`的实现:

func Copy(dst Writer, src Reader) (written int64, err error) {
       // Copy 函数 调用了 copyBuffer 函数来实现
       return copyBuffer(dst, src, nil)
    }
    
    func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
       // 如果 源Reader 实现了 WriterTo 接口,直接调用该方法 将数据写入到 目标Writer 当中
       if wt, ok := src.(WriterTo); ok {
          return wt.WriteTo(dst)
       }
       // 同理，如果 目标Writer 实现了 ReaderFrom 接口,直接调用ReadFrom方法
       if rt, ok := dst.(ReaderFrom); ok {
          return rt.ReadFrom(src)
       }
       // 如果没有传入缓冲区，此时默认 创建一个 缓冲区
       if buf == nil {
          // 默认缓冲区 大小为 32kb
          size := 32 * 1024
          // 如果源Reader 为LimitedReader, 此时比较 可读数据数 和 默认缓冲区，取较小那个
          if l, ok := src.(*LimitedReader); ok && int64(size) > l.N {
             if l.N < 1 {
                size = 1
             } else {
                size = int(l.N)
             }
          }
          buf = make([]byte, size)
       }
       for {
          // 调用Read方法 读取数据
          nr, er := src.Read(buf)
          if nr > 0 {
             // 将数据写入到 目标Writer 当中
             nw, ew := dst.Write(buf[0:nr])
             // 判断写入是否 出现了 错误
             if nw < 0 || nr < nw {
                nw = 0
                if ew == nil {
                   ew = errInvalidWrite
                }
             }
             // 累加 总写入数据
             written += int64(nw)
             if ew != nil {
                err = ew
                break
             }
             // 写入字节数 小于 读取字节数,此时报错
             if nr != nw {
                err = ErrShortWrite
                break
             }
          }
          if er != nil {
             if er != EOF {
                err = er
             }
             break
          }
       }
       return written, err
    }

从上述基本原理和代码实现来看，`io.Copy` 函数的实现还是非常简单的，就是申请一个缓冲区，然后从源Reader读取一些数据放到缓冲区中，然后再将缓冲区的数据写入到 目标Writer， 如此往复，直到数据全部读取完成。

## 4. 注意事项 ##

#### 4.1 注意关闭源Reader和目标Writer ####

在使用`io.Copy` 进行数据拷贝时，需要指定源Reader 和 目标Writer，当`io.Copy` 完成数据拷贝工作后，我们需要调用`Close` 方法关闭 源Reader 和 目标Writer。如果没有适时关闭资源，可能会导致一些不可预料情况的出现。

下面展示一个使用 `io.Copy` 进行文件复制的代码示例，同时简单说明不适时关闭资源可能导致的问题：

package main
    
    import (
            "fmt"
            "io"
            "os"
    )
    
    func main() {
            sourceFile := "source.txt"
            destinationFile := "destination.txt"
    
            // 打开源文件
            src, err := os.Open(sourceFile)
            if err != nil {
                    fmt.Println("无法打开源文件:", err)
                    return
            }
            // 调用Close方法
            defer src.Close()
    
            // 创建目标文件
            dst, err := os.Create(destinationFile)
            if err != nil {
                    fmt.Println("无法创建目标文件:", err)
                    return
            }
            // 调用Close 方法
            defer dst.Close()
    
            // 执行文件复制
            _, err = io.Copy(dst, src)
            if err != nil {
                    fmt.Println("复制文件出错:", err)
                    return
            }
    
            fmt.Println("文件复制成功!")
    }

使用 `io.Copy` 函数将源文件的内容复制到目标文件中。在结束代码之前，我们需要适时地关闭源文件和目标文件。以上面使用`io.Copy` 实现文件复制功能为例，如果我们没有适时关闭资源，首先是可能会导致文件句柄泄漏，数据不完整等一系列问题的出现。

因此我们在`io.Copy`函数之后，需要在适当的地方调用`Close`关闭系统资源。

#### 4.2 考虑性能问题 ####

`io.Copy` 函数默认使用一个32KB大小的缓冲区来复制数据，如果我们处理的是大型文件，亦或者是高性能要求的场景，此时是可以考虑直接使用`io.CopyBuffer` 函数，自定义缓冲区大小，以优化复制性能。而`io.Copy`和`io.CopyBuffer` 底层其实都是调用`io.copyBuffer` 函数的，二者底层实现其实没有太大的区别。

下面通过一个基准测试，展示不同缓冲区大小对数据拷贝性能的影响:

func BenchmarkCopyWithBufferSize(b *testing.B) {
       // 本地运行时, 文件大小为 100 M
       filePath := "largefile.txt"
       bufferSizes := []int{32 * 1024, 64 * 1024, 128 * 1024} // 不同的缓冲区大小
    
       for _, bufferSize := range bufferSizes {
          b.Run(fmt.Sprintf("BufferSize-%d", bufferSize), func(b *testing.B) {
             for n := 0; n < b.N; n++ {
                src, _ := os.Open(filePath)
                dst, _ := os.Create("destination.txt")
    
                buffer := make([]byte, bufferSize)
                _, _ = io.CopyBuffer(dst, src, buffer)
    
                _ = src.Close()
                _ = dst.Close()
                _ = os.Remove("destination.txt")
             }
          })
       }
    }

这里我们定义的缓冲区大小分别是32KB, 64KB和128KB，然后使用该缓冲区来拷贝数据。下面我们看基准测试的结果:

BenchmarkCopyWithBufferSize/BufferSize-32768-4                        12         116494592 ns/op
    BenchmarkCopyWithBufferSize/BufferSize-65536-4                        10         110496584 ns/op
    BenchmarkCopyWithBufferSize/BufferSize-131072-4                       12          87667712 ns/op

从这里看来，32KB大小的缓冲区拷贝一个100M的文件，需要`116494592 ns/op`, 而128KB大小的缓冲区拷贝一个100M的文件，需要`87667712 ns/op`。不同缓冲区的大小，确实是会对拷贝的性能有一定的影响。

在实际使用中，根据文件大小、系统资源和性能需求，可以根据需求进行缓冲区大小的调整。较小的文件通常可以直接使用`io.Copy` 函数默认的 32KB 缓冲区，而较大的文件可能需要更大的缓冲区来提高性能。通过合理选择缓冲区大小，可以获得更高效的文件复制操作。

## 5. 总结 ##

`io.Copy` 函数是Go语言标准库提供的一个工具函数，能够将数据从源Reader复制到目标Writer。 我们先从`io.Copy` 函数的基本定义出发，之后通过一个简单的示例，展示如何使用`io.Copy` 函数实现数据拷贝。

接着我们讲述了`io.Copy` 函数的实现原理，其实就是定义了一个缓冲区，将源Reader数据写入到缓冲区中，然后再将缓冲区的数据写入到目标Writer，不断重复这个过程，实现了数据的拷贝。

在注意事项方面，则强调了及时关闭源Reader和目标Writer的重要性。以及用户在使用时，需要考虑`io.Copy`函数的性能是否能够满足要求，之后通过基准测试展示了不同缓冲区大小可能带来的性能差距。

基于此，完成了对`io.Copy` 函数的介绍，希望对你有所帮助。