面试题：Rust中BufReader和BufWriter性能调优

缓冲区大小调整

原理：适当增大BufReader和BufWriter的缓冲区大小，可以减少系统调用次数，从而提升性能。对于读取操作，较大的缓冲区能一次性读取更多数据，减少磁盘I/O次数；对于写入操作，较大缓冲区能积攒更多数据后一次性写入，减少文件系统I/O次数。
代码示例：

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    // 以较大缓冲区大小创建BufReader
    file, err := os.Open("source.txt")
    if err != nil {
        fmt.Println("Open file error:", err)
        return
    }
    defer file.Close()
    // 例如将缓冲区大小设置为32KB
    reader := bufio.NewReaderSize(file, 32*1024)

    // 以较大缓冲区大小创建BufWriter
    outFile, err := os.Create("destination.txt")
    if err != nil {
        fmt.Println("Create file error:", err)
        return
    }
    defer outFile.Close()
    writer := bufio.NewWriterSize(outFile, 32*1024)
}

并发控制

原理：在高并发读取多个文件场景中，合理控制并发数可以避免资源竞争（如文件句柄资源、内存资源等）导致的性能问题。通过限制并发数，可以确保系统资源的有效利用，避免因过多的并发操作导致系统负载过高而降低整体性能。
使用Go语言的sync.WaitGroup和channel实现并发控制：

package main

import (
    "bufio"
    "fmt"
    "os"
    "sync"
)

func readAndProcessFile(filePath string, wg *sync.WaitGroup, resultChan chan string) {
    defer wg.Done()
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println("Open file error:", err)
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    var data string
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            break
        }
        data += line
    }
    // 模拟数据处理
    processedData := processData(data)
    resultChan <- processedData
}

func processData(data string) string {
    // 这里是具体的数据处理逻辑
    return data
}

func main() {
    filePaths := []string{"file1.txt", "file2.txt", "file3.txt"}
    var wg sync.WaitGroup
    resultChan := make(chan string, len(filePaths))
    maxConcurrent := 3 // 限制最大并发数
    semaphore := make(chan struct{}, maxConcurrent)

    for _, filePath := range filePaths {
        semaphore <- struct{}{}
        wg.Add(1)
        go func(fp string) {
            defer func() { <-semaphore }()
            readAndProcessFile(fp, &wg, resultChan)
        }(filePath)
    }

    go func() {
        wg.Wait()
        close(resultChan)
    }()

    outFile, err := os.Create("summary.txt")
    if err != nil {
        fmt.Println("Create file error:", err)
        return
    }
    defer outFile.Close()
    writer := bufio.NewWriter(outFile)

    for result := range resultChan {
        _, err := writer.WriteString(result)
        if err != nil {
            fmt.Println("Write file error:", err)
            return
        }
    }
    writer.Flush()
}

在上述代码中：

semaphore是一个带缓冲的通道，用于控制并发数。
readAndProcessFile函数负责读取文件、处理数据并将结果发送到resultChan。
main函数中启动多个协程并发处理文件，通过semaphore限制并发数，最后将处理结果写入汇总文件。

面试题：Rust中BufReader和BufWriter性能调优

知识考点

面试题答案

缓冲区大小调整

并发控制