Golang高效并发处理文件技巧

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()
}

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()
}

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)
    }
}
}

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
}