在处理大文件时，如果一次性将整个文件加载到内存中，很容易导致内存占用过高甚至程序崩溃。Golang作为一门适合后端开发的语言，提供了多种文件读取的方式，其中分块读取是控制内存占用的有效手段。
为什么需要分块读取大文件
当文件大小超过可用内存时，一次性读取整个文件会导致内存溢出，程序直接退出。即使文件大小小于可用内存，一次性读取也会占用大量内存，影响其他服务的运行。分块读取的核心思路是每次只读取固定大小的内容到内存中，处理完成后再读取下一块，全程内存占用仅和缓冲区大小相关，不会随文件大小增长。
Golang分块读取的核心实现
Golang标准库的os和bufio包提供了文件读取的基础能力，我们可以结合io.Reader接口的Read方法实现分块读取。
基础分块读取示例
下面的代码实现了每次读取1MB大小的文件块，直到文件读取完毕：
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func readLargeFileByChunk(filePath string, chunkSize int) error {
// 打开文件
file, err := os.Open(filePath)
if err != nil {
return fmt.Errorf("打开文件失败: %v", err)
}
defer file.Close()
// 创建带缓冲的读取器
reader := bufio.NewReader(file)
chunk := make([]byte, chunkSize)
chunkIndex := 0
for {
// 读取指定大小的块
n, err := reader.Read(chunk)
if err != nil && err != io.EOF {
return fmt.Errorf("读取文件块失败: %v", err)
}
if n == 0 {
// 读取完毕
break
}
// 处理当前块的内容，这里仅打印块序号和大小
fmt.Printf("处理第 %d 块，大小: %d 字节n", chunkIndex, n)
// 实际业务中可以在这里添加处理逻辑，比如解析内容、写入其他存储等
chunkIndex++
if err == io.EOF {
break
}
}
return nil
}
func main() {
// 设置块大小为1MB
chunkSize := 1024 * 1024
err := readLargeFileByChunk("large_test_file.bin", chunkSize)
if err != nil {
fmt.Printf("处理文件出错: %vn", err)
}
}
代码逻辑说明
- 首先通过
os.Open打开目标文件，使用defer确保文件最后被关闭，避免资源泄漏。 - 创建
bufio.Reader作为读取器，提升读取效率，同时预分配一个大小为chunkSize的字节切片作为缓冲区。 - 循环调用
Read方法读取内容，每次最多读取chunkSize字节，返回实际读取的字节数n和可能的错误。 - 当
n为0且错误为io.EOF时，说明文件已经读取完毕，退出循环。 - 每一块读取完成后，可以在对应位置添加自定义的业务处理逻辑，比如解析文本内容、计算哈希值、写入数据库等。
更灵活的分块读取方式
如果需要更精确地控制读取位置，比如需要跳过文件头部或者从指定偏移量开始读取，可以使用io.ReadAt方法，该方法属于*os.File类型，支持指定偏移量读取：
package main
import (
"fmt"
"io"
"os"
)
func readFileAtOffset(filePath string, offset int64, chunkSize int) error {
file, err := os.Open(filePath)
if err != nil {
return fmt.Errorf("打开文件失败: %v", err)
}
defer file.Close()
chunk := make([]byte, chunkSize)
currentOffset := offset
chunkIndex := 0
for {
// 从指定偏移量开始读取
n, err := file.ReadAt(chunk, currentOffset)
if err != nil && err != io.EOF {
return fmt.Errorf("读取文件块失败: %v", err)
}
if n == 0 {
break
}
fmt.Printf("从偏移量 %d 开始读取第 %d 块，大小: %d 字节n", currentOffset, chunkIndex, n)
// 处理当前块
chunkIndex++
currentOffset += int64(n)
if err == io.EOF {
break
}
}
return nil
}
func main() {
// 从第1024字节开始读取，块大小1MB
err := readFileAtOffset("large_test_file.bin", 1024, 1024*1024)
if err != nil {
fmt.Printf("处理文件出错: %vn", err)
}
}
分块处理时的注意事项
- 缓冲区大小选择：块大小建议根据业务场景和内存限制设置，一般1MB到64MB之间比较合适，过小的块会增加IO次数，过大的块会提升内存占用。
- 错误处理：读取过程中需要正确判断
io.EOF错误，避免把正常的文件结束当成异常处理。 - 资源释放：文件打开后一定要确保关闭，避免文件句柄泄漏，尤其是在循环中处理多个文件时。
- 并发处理：如果单块处理逻辑比较耗时，可以考虑将块放入通道，使用多个 goroutine 并发处理，提升整体处理效率，但需要注意并发安全和结果顺序问题。
常见场景示例：分块计算文件哈希
下面示例展示如何使用分块读取的方式计算大文件的MD5值，避免一次性加载整个文件到内存：
package main
import (
"bufio"
"crypto/md5"
"fmt"
"io"
"os"
)
func getFileMD5ByChunk(filePath string, chunkSize int) (string, error) {
file, err := os.Open(filePath)
if err != nil {
return "", fmt.Errorf("打开文件失败: %v", err)
}
defer file.Close()
hash := md5.New()
reader := bufio.NewReader(file)
chunk := make([]byte, chunkSize)
for {
n, err := reader.Read(chunk)
if err != nil && err != io.EOF {
return "", fmt.Errorf("读取文件块失败: %v", err)
}
if n == 0 {
break
}
// 将当前块的内容写入哈希计算器
hash.Write(chunk[:n])
if err == io.EOF {
break
}
}
return fmt.Sprintf("%x", hash.Sum(nil)), nil
}
func main() {
md5Val, err := getFileMD5ByChunk("large_test_file.bin", 1024*1024)
if err != nil {
fmt.Printf("计算MD5失败: %vn", err)
return
}
fmt.Printf("文件MD5值: %sn", md5Val)
}