在Golang开发中，处理大文件时如果直接使用ioutil.ReadFile这类一次性读取全部内容的方式，很容易因为文件体积过大导致内存占用飙升甚至程序崩溃，因此需要采用更合理的读取策略。不同的业务场景对读取的要求不同，选择合适的方法才能在保证功能的同时兼顾性能。
基础读取方式
按行读取大文件
如果大文件是文本类型，且需要逐行处理内容，使用bufio.Scanner是比较简单的方式，它会自动处理换行符，逐行读取内容，不需要手动管理缓冲区大小。
package main
import (
"bufio"
"fmt"
"os"
)
func readLargeFileByLine(filePath string) error {
// 打开文件
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
// 创建Scanner逐行扫描
scanner := bufio.NewScanner(file)
lineNum := 0
for scanner.Scan() {
lineNum++
// 处理当前行内容，这里仅打印行号和前20个字符
line := scanner.Text()
if len(line) > 20 {
fmt.Printf("第%d行内容：%sn", lineNum, line[:20])
} else {
fmt.Printf("第%d行内容：%sn", lineNum, line)
}
}
// 检查扫描过程中是否有错误
if err := scanner.Err(); err != nil {
return err
}
return nil
}
func main() {
// 替换为实际的大文件路径
err := readLargeFileByLine("large_text_file.txt")
if err != nil {
fmt.Printf("读取文件失败：%vn", err)
}
}
这种方式适合行结构清晰的文本大文件，内存占用低，但是bufio.Scanner有默认的行长度限制，如果单行内容过长可能会读取失败，此时可以调整scanner.Buffer的大小。
分块读取大文件
如果文件不是文本类型，或者需要按固定大小分块处理，可以使用io.Reader配合缓冲区实现分块读取，每次只读取指定大小的内容到内存中。
package main
import (
"fmt"
"io"
"os"
)
func readLargeFileByChunk(filePath string, chunkSize int) error {
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
buf := make([]byte, chunkSize)
chunkCount := 0
for {
// 每次读取chunkSize大小的内容
n, err := file.Read(buf)
if n > 0 {
chunkCount++
// 处理当前块的内容，这里仅打印块编号和读取到的字节数
fmt.Printf("第%d块，读取到%d字节n", chunkCount, n)
}
if err == io.EOF {
// 读取到文件末尾，退出循环
break
}
if err != nil {
return err
}
}
return nil
}
func main() {
// 每块读取1MB内容，可根据需求调整大小
err := readLargeFileByChunk("large_binary_file.bin", 1024*1024)
if err != nil {
fmt.Printf("读取文件失败：%vn", err)
}
}
分块读取的块大小可以根据实际情况调整，一般建议设置为4KB到1MB之间，过小会导致读取次数过多，过大则会增加内存占用。
进阶优化方法
使用带缓冲的读取器
bufio.Reader相比普通的file.Read有内置的缓冲区，可以减少系统调用的次数，提升读取性能。它支持按字节、按行、按分隔符等多种读取方式，灵活性更高。
package main
import (
"bufio"
"fmt"
"os"
)
func readWithBufferedReader(filePath string) error {
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
// 创建带缓冲的读取器，缓冲区大小设置为4KB
reader := bufio.NewReaderSize(file, 4096)
totalBytes := 0
for {
// 每次读取最多1024字节，直到遇到换行符
line, err := reader.ReadString('n')
if len(line) > 0 {
totalBytes += len(line)
}
if err != nil {
if err == io.EOF {
break
}
return err
}
}
fmt.Printf("文件总读取字节数：%dn", totalBytes)
return nil
}
func main() {
err := readWithBufferedReader("large_text_file.txt")
if err != nil {
fmt.Printf("读取文件失败：%vn", err)
}
}
并发读取大文件
如果文件非常大，且处理逻辑可以并行，可以将文件分成多个部分，使用多个goroutine并发读取不同的部分，最后汇总处理结果，大幅提升处理速度。
package main
import (
"fmt"
"io"
"os"
"sync"
)
func readFilePart(file *os.File, start, end int64, wg *sync.WaitGroup, resultChan chan<- int) {
defer wg.Done()
// 定位到当前分片的起始位置
_, err := file.Seek(start, io.SeekStart)
if err != nil {
fmt.Printf("定位文件位置失败：%vn", err)
return
}
// 计算当前分片的大小
partSize := end - start
buf := make([]byte, 1024)
readBytes := 0
for readBytes < int(partSize) {
n, err := file.Read(buf)
if n > 0 {
readBytes += n
}
if err != nil {
if err == io.EOF {
break
}
fmt.Printf("读取分片失败：%vn", err)
return
}
}
// 将当前分片读取的字节数发送到结果通道
resultChan <- readBytes
}
func concurrentReadLargeFile(filePath string, partNum int) error {
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
// 获取文件大小
fileInfo, err := file.Stat()
if err != nil {
return err
}
fileSize := fileInfo.Size()
// 计算每个分片的大小
partSize := fileSize / int64(partNum)
if fileSize%int64(partNum) != 0 {
partSize++
}
var wg sync.WaitGroup
resultChan := make(chan int, partNum)
// 启动多个goroutine并发读取不同分片
for i := 0; i < partNum; i++ {
wg.Add(1)
start := int64(i) * partSize
end := start + partSize
if end > fileSize {
end = fileSize
}
go readFilePart(file, start, end, &wg, resultChan)
}
// 等待所有goroutine完成
wg.Wait()
close(resultChan)
totalBytes := 0
for bytes := range resultChan {
totalBytes += bytes
}
fmt.Printf("并发读取总字节数：%dn", totalBytes)
return nil
}
func main() {
// 使用4个goroutine并发读取
err := concurrentReadLargeFile("large_file.bin", 4)
if err != nil {
fmt.Printf("读取文件失败：%vn", err)
}
}
并发读取需要注意文件分片的边界问题，避免不同goroutine读取到重复的内容，同时要根据CPU核心数合理设置并发数，过多的goroutine反而会导致性能下降。
不同方式对比
以下是几种常见大文件读取方式的适用场景和特点对比：
| 读取方式 | 适用场景 | 内存占用 | 性能 |
|---|---|---|---|
| bufio.Scanner按行读取 | 文本文件逐行处理 | 低 | 中等 |
| io.Reader分块读取 | 二进制文件或固定大小分块处理 | 低 | 中等 |
| bufio.Reader缓冲读取 | 各类文件读取，需要减少系统调用 | 低 | 较高 |
| 并发分片读取 | 超大文件，处理逻辑可并行 | 中等 | 高 |
在实际开发中，需要根据文件类型、大小、处理逻辑的复杂度选择合适的读取方式，一般不需要盲目追求最优性能，满足业务需求且稳定可靠才是最重要的。