答案：Golang中通过goroutine和channel实现并发文件处理，可并行读取、处理多个文件，使用WaitGroup协调任务，结合带缓冲channel控制并发数防止资源耗尽，通过结果channel收集处理输出，支持大文件分块并行处理以提升效率。
在Golang中实现并发文件处理，关键在于合理利用goroutine和channel来并行读取、处理和写入多个文件，同时避免资源竞争和内存溢出。下面介绍几种实用的方法和最佳实践。
使用Goroutine并行处理多个文件
当需要处理多个独立文件时，可以为每个文件启动一个goroutine进行处理，通过WaitGroup等待所有任务完成。
示例：遍历目录中的文件，并发计算每个文件的行数。
func processFilesConcurrently(filenames []string) {
var wg sync.WaitGroup
for _, filename := range filenames {
wg.Add(1)
go func(file string) {
defer wg.Done()
count, err := countLines(file)
if err != nil {
log.Printf("Error reading %s: %v", file, err)
return
}
log.Printf("%s has %d lines", file, count)
}(filename)
}
wg.Wait()
}
func countLines(filename string) (int, error) {
file, err := os.Open(filename)
if err != nil {
return 0, err
}
defer file.Close()
scanner := bufio.NewScanner(file)
count := 0
for scanner.Scan() {
count++
}
return count, scanner.Err()}
控制并发数量防止资源耗尽
如果文件数量很大，直接为每个文件启动goroutine可能导致系统资源紧张。使用带缓冲的channel作为信号量，可限制最大并发数。
立即学习“go语言免费学习笔记（深入）”；
func processWithLimit(filenames []string, maxConcurrency int) {
semaphore := make(chan struct{}, maxConcurrency)
var wg sync.WaitGroup
for _, filename := range filenames {
wg.Add(1)
go func(file string) {
defer wg.Done()
semaphore <- struct{}{} // 获取令牌
defer func() { <-semaphore }() // 释放令牌
// 处理文件
result := processSingleFile(file)
log.Printf("Processed %s: %v", file, result)
}(filename)
}
wg.Wait()}
使用Channel传递处理结果
将文件处理结果通过channel返回，主协程统一收集输出或进一步处理，便于错误处理和结果聚合。
type Result struct {
Filename string
Lines int
Error error
}
func processWithResults(filenames []string) {
results := make(chan Result, len(filenames))
var wg sync.WaitGroup
for _, name := range filenames {
wg.Add(1)
go func(filename string) {
defer wg.Done()
count, err := countLines(filename)
results <- Result{Filename: filename, Lines: count, Error: err}
}(name)
}
go func() {
wg.Wait()
close(results)
}()
// 主协程接收结果
for result := range results {
if result.Error != nil {
log.Printf("Failed to process %s: %v", result.Filename, result.Error)
} else {
log.Printf("%s: %d lines", result.Filename, result.Lines)
}
}}
大文件的分块并发处理
对于单个大文件，可以将其按字节范围分块，多个goroutine并行处理不同区块，适用于日志分析等场景。
注意：文本文件需确保按行切分，避免截断行内容。
func processLargeFile(filename string) error {
file, err := os.Open(filename)
if err != nil {
return err
}
defer file.Close()
stat, _ := file.Stat()
fileSize := stat.Size()
chunkSize := fileSize / 4 // 分4块
var wg sync.WaitGroup
resultChan := make(chan int, 4)
for i := 0; i < 4; i++ {
start := int64(i) * chunkSize
end := start + chunkSize
if i == 3 {
end = fileSize
}
wg.Add(1)
go func(s, e int64) {
defer wg.Done()
count, _ := countLinesInRange(filename, s, e)
resultChan <- count
}(start, end)
}
go func() {
wg.Wait()
close(resultChan)
}()
total := 0
for n := range resultChan {
total += n
}
log.Printf("Total lines: %d", total)
return nil}
基本上就这些。Golang的并发模型让文件处理变得高效又简洁，关键是根据场景选择合适的并发策略，控制好资源使用，避免I/O阻塞影响整体性能。
