使用Goroutine和Channel可高效处理多文件并发读写。通过限制并发数量的信号量机制或WaitGroup协调任务，结合缓冲channel传递结果，能有效控制资源消耗并提升I/O性能，同时需注意错误处理与资源释放。
在高并发场景下，处理多个文件的读写操作时，Golang 的 Goroutine 和 Channel 提供了简洁高效的解决方案。通过合理使用并发机制，可以显著提升 I/O 密集型任务的执行效率。以下是实现多文件并发处理的核心思路和具体代码示例。
使用 Goroutine 并发处理多个文件
每个文件的读取或写入都可以交给独立的 Goroutine 执行，从而实现并行处理。关键在于控制并发数量，避免系统资源耗尽。
以下是一个并发读取多个文本文件内容的示例：
func readFile(path string, result chan<- string) {
data, err := os.ReadFile(path)
if err != nil {
result <- fmt.Sprintf("Error reading %s: %v", path, err)
return
}
result <- fmt.Sprintf("Read from %s: %d bytes", path, len(data))
}
func processFilesConcurrently(filenames []string) {
result := make(chan string, len(filenames))
for _, file := range filenames {
go readFile(file, result)
}
for i := 0; i < len(filenames); i++ {
fmt.Println(<-result)
}}
在这个例子中，每个文件启动一个 Goroutine 进行读取，结果通过 channel 返回。使用带缓冲的 channel 可以避免阻塞。
通过 Channel 控制并发数量
当文件数量很大时，无限制地创建 Goroutine 会导致内存暴涨或系统调用失败。可以通过带容量的 channel 实现信号量机制，限制最大并发数。
func processWithLimit(filenames []string, maxConcurrency int) {
sem := make(chan struct{}, maxConcurrency)
result := make(chan string, len(filenames))
for _, file := range filenames {
sem <- struct{}{} // 获取信号量
go func(f string) {
defer func() { <-sem }() // 释放信号量
data, err := os.ReadFile(f)
if err != nil {
result <- fmt.Sprintf("Failed: %s - %v", f, err)
return
}
result <- fmt.Sprintf("Success: %s (%d bytes)", f, len(data))
}(file)
}
// 等待所有任务完成
for i := 0; i < len(filenames); i++ {
fmt.Println(<-result)
}}
sem <- struct{}{} // 获取信号量
go func(f string) {
defer func() { <-sem }() // 释放信号量
data, err := os.ReadFile(f)
if err != nil {
result <- fmt.Sprintf("Failed: %s - %v", f, err)
return
}
result <- fmt.Sprintf("Success: %s (%d bytes)", f, len(data))
}(file)
}
// 等待所有任务完成
for i := 0; i < len(filenames); i++ {
fmt.Println(<-result)
}这种方式确保最多只有 maxConcurrency 个 Goroutine 同时运行，适合处理大量文件。
结合 WaitGroup 等待所有任务完成
除了 channel，也可以使用 sync.WaitGroup 配合 channel 来更清晰地管理生命周期。
func processWithWaitGroup(filenames []string) {
var wg sync.WaitGroup
result := make(chan string, len(filenames))
for _, file := range filenames {
wg.Add(1)
go func(f string) {
defer wg.Done()
data, err := os.ReadFile(f)
if err != nil {
result <- fmt.Sprintf("Error: %s", err)
return
}
result <- fmt.Sprintf("Processed: %s, size: %d", f, len(data))
}(file)
}
go func() {
wg.Wait()
close(result)
}()
for msg := range result {
fmt.Println(msg)
}}
这里启动一个额外 Goroutine 在所有任务完成后关闭 result channel，主协程通过 range 读取结果直到 channel 关闭。
基本上就这些。Goroutine 和 Channel 的组合让多文件处理变得简单高效，关键是根据实际负载控制并发度，避免系统过载。不复杂但容易忽略的是错误处理和资源释放，建议在生产环境中加入日志记录和超时控制。
