如何用 Golang 实现多线程文件处理_Golang 并发文件 I/O 操作实例

使用goroutine和channel可高效并发处理文件I/O。通过WaitGroup同步任务，缓冲channel收集结果，限制worker数量防止资源耗尽，并发读写不同文件安全且高效。

在 Golang 中，并发处理文件 I/O 能显著提升大批量文件操作的效率。虽然 Go 没有传统意义上的“多线程”概念，但通过 goroutine 和 channel 可以轻松实现高并发的文件处理任务。下面是一个实用的并发文件处理示例，展示如何并行读取多个文件、处理内容并安全写入结果。

使用 Goroutine 实现并发文件读取

每个文件读取任务可以交给一个独立的 goroutine 执行，避免串行等待。通过 sync.WaitGroup 控制所有任务完成后再退出主函数。

package main
import (
"bufio"
"fmt"
"os"
"sync"
)
func countLines(filename string, wg *sync.WaitGroup) {
defer wg.Done()
file, err := os.Open(filename)
if err != nil {
    fmt.Printf("无法打开文件 %s: %v\n", filename, err)
    return
}
defer file.Close()

scanner := bufio.NewScanner(file)
lines := 0
for scanner.Scan() {
    lines++
}

fmt.Printf("文件 %s 有 %d 行\n", filename, lines)

}
func main() {
filenames := []string{"log1.txt", "log2.txt", "log3.txt"}
var wg sync.WaitGroup
for _, fname := range filenames {
    wg.Add(1)
    go countLines(fname, &wg)
}

wg.Wait()
fmt.Println("所有文件处理完成")
}

带缓冲 Channel 的并发结果收集
当需要汇总各 goroutine 的处理结果时，使用 channel 将数据传回主协程，避免竞态条件。
立即学习“go语言免费学习笔记（深入）”；

							

								
								

									ios系统介绍 中文WORD版
									
本文档主要讲述的是ios系统介绍；iOS是由苹果公司为iPhone等设备开发的操作系统，它主要给iPhone、iPod touch以及 iPad设备使用，它管理设备硬件并为手机本地应用程序的实现提供基础技术。根据设备不同，操作系统具有不同的系统应用程序，例如Phone、Mail以及Safari，这些应用程序可以为用户提供标准系统服务。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以过来看看
								
								下载 
							
						
示例：并发读取文件内容长度并通过 channel 返回
func processFile(filename string, resultChan chan<- string) {
    data, err := os.ReadFile(filename)
    if err != nil {
        resultChan <- fmt.Sprintf("%s: 读取失败 - %v", filename, err)
        return
    }
    resultChan <- fmt.Sprintf("%s: 内容长度 %d 字节", filename, len(data))
}
func main() {
filenames := []string{"a.txt", "b.txt", "c.txt"}
resultChan := make(chan string, len(filenames)) // 缓冲 channel 避免阻塞
for _, fname := range filenames {
    go processFile(fname, resultChan)
}

for range filenames {
    result := <-resultChan
    fmt.Println(result)
}
close(resultChan)

}

控制并发数量：防止资源耗尽
当文件数量很大时，启动过多 goroutine 可能导致系统资源紧张。可通过带缓存的 worker channel 限制最大并发数。
func limitedConcurrency() {
    filenames := getLargeFileList() // 假设有上千个文件
    sem := make(chan struct{}, 10)  // 最多 10 个并发
    var wg sync.WaitGroup
for _, fname := range filenames {
    wg.Add(1)
    go func(file string) {
        defer wg.Done()
        sem <- struct{}{}         // 获取信号量
        defer func() { <-sem }()  // 释放信号量

        // 处理文件
        data, _ := os.ReadFile(file)
        fmt.Printf("处理 %s, 大小: %d\n", file, len(data))
    }(fname)
}

wg.Wait()

}

并发写入不同文件是安全的
Go 的文件写入在不同文件间并发操作是安全的，只要每个 goroutine 写入独立文件，无需额外锁机制。
func writeFile(content string, filename string) {
    err := os.WriteFile(filename, []byte(content), 0644)
    if err != nil {
        fmt.Printf("写入失败 %s: %v\n", filename, err)
    } else {
        fmt.Printf("成功写入 %s\n", filename)
    }
}
// 多个 goroutine 并发写入不同文件没问题
go writeFile("data1", "out1.txt")
go writeFile("data2", "out2.txt")

基本上就这些。Golang 的并发模型让文件 I/O 处理变得简洁高效。合理使用 goroutine、channel 和 WaitGroup，既能提升性能，又能保证程序稳定。关键是控制好并发度，避免系统过载。