【终于明白了】源码+图解分析梳理 Golang 中输入输出I/O_研究go中的i/o

前言

输入输出（I/O）是一个程序最基础的一部分。而Golang中涉及io的包非常多，对于小白很容易混淆，现在就来花一点时间来把梳理清楚。

本文将主要涉及以下的几个包

• io
  • io.ioutil
• bufio
• bytes
• strings
• net
• os

标准库的区别

首先需要从高层次上来区分开这几个包。在官网Standard library · std · pkg.go.dev中，这几个包的区别和侧重点如下

1. 提供基本接口的io

io库是GO语言中的核心，其中定义了IO操作中的相关接口。

最基础的接口 io.Reader与io.Writer

在io中最基础的就是读和写, 这两个的接口如下：

type Reader interface {
	Read(p []byte) (n int, err error) //接收一个字节切片p,将读取的数据放入到p中，返回读取了的字节个数
}

type Writer interface {
	Write(p []byte) (n int, err error) //接收一个字节切片p,将p中的数据写入到文件或文件中，返回写入了的字节个数
}
1
2
3
4
5
6
7

这俩个接口定义了最基本的读与写。

辅助接口 io.Seeker与io.Closer

在io中，定义了 io.Seeker与io.Closer来设置光标和关闭。

type Seeker interface {
	Seek(offset int64, whence int) (int64, error) // 设置相对于whence偏移offset的读或者写的偏移量，返回相对于文件开始的新偏移量和一个错误
}

type Closer interface {
	Close() error  //关闭数据流
}
1
2
3
4
5
6
7

进阶：偏移量指定io.ReaderAt和io.WriterAt

io.ReaderAt和io.WriterAt两个接口在io.Reader与io.Writer的基础上增加了指定偏移量的操作

type ReaderAt interface {
    ReadAt(p []byte, off int64) (n int, err error) //从基本输入源的偏移量 off 处开始，将 len(p) 个字节读取到 p 中,它返回读取的字节数 n（0 <= n <= len(p)）以及任何遇到的错误。
}

type WriterAt interface {
    WriteAt(p []byte, off int64) (n int, err error) //从 p 中将 len(p) 个字节写入到偏移量 off 处的基本数据流中。它返回从 p 中被写入的字节数 n（0 <= n <= len(p)）以及任何遇到的引起写入提前停止的错误
}
1
2
3
4
5
6
7

进阶：来源与去处指定 io.ReaderFrom和 io.WiterTo

io.ReaderFrom和io.WriterTo两个接口相比于io.Reader与io.Writer，指定了各自的输入和输出的对象

type ReaderFrom interface {
    ReadFrom(r Reader) (n int64, err error) //从 r 中读取数据，直到 EOF 或发生错误。其返回值 n 为读取的字节数
}

type WriterTo interface {
    WriteTo(w Writer) (n int64, err error) //将数据写入 w 中，直到没有数据可写或发生错误。其返回值 n 为写入的字节数
}
1
2
3
4
5
6
7

适配：各种数据类型的读取与写入

io库中也针对byte、Rune，string类型的数据实现了各自的Reader和Writer

Byte 读写一个字节

type ByteReader interface {
    ReadByte() (c byte, err error) //读一个字节
}

type ByteWriter interface {
    WriteByte(c byte) error       //写一个字节
}

type ByteScanner interface {
    ByteReader                    // 内嵌了 ByteReader 接口
    UnreadByte() error            // 将上一次 ReadByte 的字节还原
}
1
2
3
4
5
6
7
8
9
10
11
12

Rune 读一个字符

type RuneReader interface {
	ReadRune() (r rune, size int, err error) //读一个字符r 返回尺寸size 和错误
}

type RuneScanner interface {
	RuneReader
	UnreadRune() error
}
1
2
3
4
5
6
7
8

注意：没有RuneWriter接口，据说是开发者认为几乎不需要RuneWriter接口

String 写入一个字符串

type StringWriter interface {
	WriteString(s string) (n int, err error) //字符串s的内容写到w
}
1
2
3

组合：各式各样的接口搭配

上面的都是一些单一的接口，而有些时候同时需要莫两个或者三个的接口的所有功能，所以在io库中提供了这些“小接口”组合而成的“大接口”。

• type ReadSeekCloser
• type ReadSeeker
• type ReadCloser
• type ReadWriteCloser
• type ReadWriteSeeker
• type ReadWriter
• type WriteCloser
• type WriteSeeker

总结：io库中的所有接口概要图

以上的接口可以归纳为下图

实现：接口的各种实现场景

在不同的标准库场景中，分别实现了io库中的接口：

• bufio中实现了带缓冲的io

• os中实现了file,stdin,stdout,stderr的io

• net中实现了网络io

• strings中实现了字符串io

• bytes中实现了字节io

• compress,crypto …

  

附：io库中的一些变量与方法

除了接口，io库中还有相对应的一些变量、方法和接口实现（后续讲）。

显示各种错误的变量

io库中的变量主要是一些错误。

• EOF 没有更多输入可以读取
• ErrClosePipe 读取或写入一个关闭的通道
• ErrNoProgress 当许多对Read的调用都没有返回任何数据或错误时，通常是Reader实现失败的标志
• ErrShortBuffer 缓冲区过短
• ErrShortWrite 写入时接受的字节数比要求的少
• ErrUnexpectedEOF 在读取一个固定大小的块或数据结构的过程中遇到了EOF

各种相关操作方法

• 复制
  • func Copy(dst Writer, src Reader) (written int64, err error) 复制
  • func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) 缓冲复制
  • func CopyN(dst Writer, src Reader, n int64) (written int64, err error) 复制N个字节
• 管道
  • func Pipe() (*PipeReader, *PipeWriter) 创建一个内存中同步管道
• 读取
  • func ReadAll(r Reader) ([]byte, error) 读取所有
  • func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) 至少读取min个字节
  • func ReadFull(r Reader, buf []byte) (n int, err error) 读取buf长度
• 写入
  • func WriteString(w Writer, s string) (n int, err error) 将字符串s的内容写到w，w接受一个字节切片

2. 实用的io.ioutil

可以看到io大部分都只是提供了一些接口，所以使用起来不是那么方便。所以标准库io.ioutil提供了一些方便的操作函数。

[实现一] 带缓冲的bufio

疑问：缓冲的作用

很明显，bufio比io多了一个缓冲buf。那么，缓冲有何作用？

这是因为在一些很小的写入和读取时，很耗费io。 这时可以把这些小片段的数据放在缓冲中，然后再统一读取或写入，这样可以大大的提高效率。

实现：Reader读取器

bufio中的Reader实现了io中的接口。

bufio.Reader结构体

type Reader struct {
	buf          []byte    // 缓冲区，为字节切片
	rd           io.Reader // reader 由 client 提供
	r, w         int       // 缓冲区读写的位置
	err          error
	lastByte     int // UnreadByte的最后读取的字节；-1表示无效
	lastRuneSize int // UnreadRune最后读取的字符大小；-1表示无效
}
1
2
3
4
5
6
7
8

bufio.Reader创建

const (
	defaultBufSize = 4096  //默认大小
)

const minReadBufferSize = 16 //最小尺寸

func NewReaderSize(rd io.Reader, size int) *Reader {
    // Is it already a Reader?
    b, ok := rd.(*Reader)
    if ok && len(b.buf) >= size {
        return b
    }
    if size < minReadBufferSize { //minReadBufferSize==16
        size = minReadBufferSize
    }
    r := new(Reader)
    r.reset(make([]byte, size), rd)
    return r
}

// NewReader returns a new Reader whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
    return NewReaderSize(rd, defaultBufSize)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

可以看到有两个方法NewReader()和NewReaderSize()可以创建bufio.Reader。区别在于NewReader()使用默认的尺寸（4096）来调用NewReaderSize()来实现，而NewReaderSize()则可以自己指定尺寸，注意最小值为16。

bufio.Reader的方法及接口实现

实现：Writer写入器

bufio.writer结构体

type Writer struct {
	err error      //错误
	buf []byte     //缓冲区
	n   int
	wr  io.Writer
}
1
2
3
4
5
6

bufio.Writer创建

func NewWriterSize(w io.Writer, size int) *Writer {
	// Is it already a Writer?
	b, ok := w.(*Writer)
	if ok && len(b.buf) >= size {
		return b
	}
	if size <= 0 {
		size = defaultBufSize
	}
	return &Writer{
		buf: make([]byte, size),
		wr:  w,
	}
}

func NewWriter(w io.Writer) *Writer {
	return NewWriterSize(w, defaultBufSize)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

可以看到，类似于bufio.Reader，bufio.Writer也有两种方法，一种是默认大小的方式NewWriter和可以指定尺寸的NewWriterSize方式，而当尺寸小于0时为默认大小4096。

bufio.Writer方法及接口实现

附：Scanner扫描仪

扫描器模块的主要作用是把数据流分割成一个个标记并除去它们之间的空格

bufio.Scanner结构体

type Scanner struct {
	r            io.Reader // 由client提供的reader.
	split        SplitFunc // 分隔标记的函数.
	maxTokenSize int       // 标记的最大尺寸
	token        []byte    // 由split返回的最后一个token
	buf          []byte    // 用作分割参数的缓冲区
	start        int       // buf中第一个未处理的字节
	end          int       // 缓冲区内的数据结束
	err          error     // 错误
	empties      int       // 连续的空标记的数量
	scanCalled   bool      // 扫描已被调用；缓冲区正在使用中
	done         bool      // 扫描已完成
}
1
2
3
4
5
6
7
8
9
10
11
12
13

bufio.Scanner创建

const (
	MaxScanTokenSize = 64 * 1024

	startBufSize = 4096 // Size of initial allocation for buffer.
)


func NewScanner(r io.Reader) *Scanner {
	return &Scanner{
		r:            r,                    
		split:        ScanLines,          //默认函数
		maxTokenSize: MaxScanTokenSize,   //64*4096
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

bufio.Scanner的方法

[实现二] 文件io的os

与文件进行交互是程序中常见的一个行为。在os库中，实现了对与文件的io。

实现：os.File

os.File结构体

type File struct {
	*file // os specific
}

/*file_unix.go*/
type file struct {
	pfd         poll.FD
	name        string   // 名称
	dirinfo     *dirInfo // nil unless directory being read
	nonblock    bool     // whether we set nonblocking mode
	stdoutOrErr bool     // whether this is stdout or stderr
	appendMode  bool     // whether file is opened for appending
}
1
2
3
4
5
6
7
8
9
10
11
12
13

可以看到由于不同的操作系统的文件实现方式不一致，所以因操作系统而各异。

os.File的创建

/*file_unix.go*/ 
// 给定文件描述符fd和文件名 返回一个新的文件
func NewFile(fd uintptr, name string) *File {
	kind := kindNewFile
	if nb, err := unix.IsNonblock(int(fd)); err == nil && nb {
		kind = kindNonBlock
	}
	return newFile(fd, name, kind)
} 
1
2
3
4
5
6
7
8
9

os.File的方法和接口实现

实现: 其实就是文件的stdin,stdout,stderr

而对于标准输入输出stdin,stdout,stderr它们其实就是指定的File。

var (
	Stdin  = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
	Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
	Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
)
1
2
3
4
5

[实现三] 网络io的net

实现：Conn接口与conn实现

net.Conn接口

在net库中，定义了底层的接口Conn。

type Conn interface {
	Read(b []byte) (n int, err error)
	Write(b []byte) (n int, err error)
	Close() error
	LocalAddr() Addr
	RemoteAddr() Addr
	SetDeadline(t time.Time) error
	SetReadDeadline(t time.Time) error
	SetWriteDeadline(t time.Time) error
}
1
2
3
4
5
6
7
8
9
10

net.conn结构体

同时也实现了一个接口类型conn

type conn struct {
	fd *netFD
}
1
2
3

net.conn接口实现

[实现四] 字符串处理的strings

实现：strings.Reader

对字符串进行功效处理，在strings里面有一个Reader数据结构。

string.Reader结构体

type Reader struct {
	s        string  //字符串
	i        int64   // 当前读取下标
	prevRune int     // 先前读取字符的下标
}
1
2
3
4
5

string.Reader方法及接口实现

[实现五] 字节处理的bytes

实现：bytes.Reader

类似于strings，byte中也有一个Reader。它两大体类似，只是区别于一个s是string,一个是[]byte。篇幅有限，就不具体展开。

实现：bytes.Buffer

bytes.Buffer是一个可变大小的字节缓冲区，可以读也可以写。

bytes.Buffer结构体

type Buffer struct {
	buf      []byte // 缓冲区 内容为buf[off : len(buf)]
	off      int    //  读在 &buf[off], 写在 &buf[len(buf)]
	lastRead readOp // 上一次读的操作
}
1
2
3
4
5

bytes.Buffer方法与接口实现

总结 来个SUMMARY

1. io是Go中输入输出处理的最基本的库，它定义了许多相关接口
2. 由于io大部分是定义的接口，使用起来不太实用。io.ioutil提供了许多方便的实用函数
3. 其它库从不同方面分别实现了io中的接口
   1. bufio实现了带缓冲的io
   2. os实现了文件io
   3. net实现了网络io
   4. strings实现了字符串处理io
   5. bytes实现了字节处理io