使用Goroutine和通道实现多文件并发读写，通过WaitGroup协调任务，以带缓冲channel控制并发数防止资源耗尽，确保每个Goroutine独立操作文件避免共享资源，结合errgroup统一错误处理并及时释放文件句柄，提升IO效率同时保障程序稳定。
在Golang中处理多文件并发读写时，核心是利用Goroutine和通道（channel）实现并发控制，同时避免资源竞争和系统负载过高。Go语言的并发模型简洁高效，但多文件操作涉及IO密集型任务，需合理管理并发数量、错误处理和资源释放。
使用WaitGroup控制并发读写
当需要同时读取或写入多个文件时，可启动多个Goroutine，并用sync.WaitGroup等待所有任务完成。
示例：并发读取多个文件内容
func readFilesConcurrently(filenames []string) {
var wg sync.WaitGroup
for _, filename := range filenames {
wg.Add(1)
go func(file string) {
defer wg.Done()
data, err := os.ReadFile(file)
if err != nil {
log.Printf("读取文件失败 %s: %v", file, err)
return
}
// 处理数据
fmt.Printf("文件 %s 读取成功，长度: %d\n", file, len(data))
}(filename)
}
wg.Wait()
}
注意：闭包中传递filename变量时，必须作为参数传入，避免Goroutine共享同一个变量导致错乱。
立即学习“go语言免费学习笔记（深入）”；
限制并发数量防止资源耗尽
如果文件数量很大，直接为每个文件启动Goroutine可能导致内存暴涨或文件句柄不足。可通过带缓冲的channel控制最大并发数。
func limitedConcurrentRead(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 }() // 释放令牌
data, err := os.ReadFile(file)
if err != nil {
log.Printf("读取失败 %s: %v", file, err)
return
}
fmt.Printf("处理完成: %s\n", file)
// 模拟耗时操作
time.Sleep(100 * time.Millisecond)
}(filename)
}
wg.Wait()}
这种方式通过信号量机制限制同时运行的Goroutine数量，保护系统资源。
并发写入多个文件的注意事项
并发写文件时，除了控制并发度，还需确保每个Goroutine独立打开和关闭文件，避免共享*os.File实例。
示例：安全并发写入
func writeToFile(filename, content string) error {
file, err := os.Create(filename)
if err != nil {
return err
}
defer file.Close()
_, err = file.WriteString(content)
return err
}
// 并发调用
for i := 0; i go func(id int) {
defer wg.Done()
err := writeToFile(fmt.Sprintf("output_%d.txt", id), fmt.Sprintf("Hello from %d", id))
if err != nil {
log.Printf("写入失败: %v", err)
}
}(i)
}
wg.Wait()
关键点：每次写入都独立调用os.Create并及时关闭，防止文件句柄泄漏。
使用ErrGroup增强错误处理
对于需要统一错误处理的场景，推荐使用golang.org/x/sync/errgroup包，它能自动传播第一个返回的错误并取消其他任务。
import "golang.org/x/sync/errgroup"func processWithErrGroup(filenames []string) error { var g errgroup.Group for _, file := range filenames { file := file // 避免变量捕获问题 g.Go(func() error { data, err := os.ReadFile(file) if err != nil { return fmt.Errorf("读取 %s 失败: %w", file, err) } // 处理逻辑... fmt.Printf("已处理: %s\n", file) return nil }) } return g.Wait() // 等待所有任务，返回首个非nil错误 }
该方法适合要求“任一失败即整体失败”的场景，也可结合context实现超时控制。
基本上就这些。合理使用并发原语，既能提升IO效率，又能保证程序稳定。关键是控制并发规模、正确处理闭包变量、及时释放资源。不复杂但容易忽略细节。
