Wie lese und schreibe ich Dateien gleichzeitig in Golang?

Gleichzeitiges Lesen von Dateien: Erstellen Sie eine Goroutine, um Datenblöcke gleichzeitig zu lesen, und verwenden Sie die Koordinierung der Pipeline-Kommunikation. Verwenden Sie Goroutine, um Daten zu schreiben, und verwenden Sie einen Mutex, um den Schreibvorgang zu schützen.

Wie lese und schreibe ich Dateien gleichzeitig in Golang?

Die gleichzeitige Verarbeitung von Datei-E/A ist eine gängige Technik zur Verbesserung der Leistung von Golang-Programmen. Mit gleichzeitigem Zugriff können wir Daten gleichzeitig lesen und schreiben, anstatt auf den Abschluss eines Vorgangs zu warten, bevor wir einen anderen starten. In diesem Artikel wird gezeigt, wie Sie mit Goroutine Dateien in Golang gleichzeitig lesen und schreiben können.

Gleichzeitiges Lesen

Um Dateien gleichzeitig zu lesen, können wir mehrere Goroutinen erstellen. Jede Goroutine liest Datenblöcke aus der Datei. Um diese Goroutinen zu koordinieren, verwenden wir Pipes zur Kommunikation.

package main

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

func readFile(filePath string, wg *sync.WaitGroup, ch chan<- string) {
    defer wg.Done()
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        ch <- scanner.Text()
    }
}

func main() {
    // 创建一个容量为 10 的管道
    ch := make(chan string, 10)

    // 等待组用于跟踪 goroutine
    var wg sync.WaitGroup

    filePath := "filename.txt"
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go readFile(filePath, &wg, ch)
    }

    // 从管道中读取数据，并停止管道以等待所有 goroutine 完成
    go func() {
        wg.Wait()
        close(ch)
    }()

    for data := range ch {
        fmt.Println(data)
    }

    // 等待管道数据完全输出
    time.Sleep(1 * time.Second)
}

Gleichzeitiges Schreiben

Für gleichzeitiges Schreiben in Dateien verwenden wir einen ähnlichen Ansatz, verwenden jedoch eine Goroutine zum Schreiben der Daten und einen Mutex, um den exklusiven Zugriff auf den Schreibvorgang sicherzustellen.

package main

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

func writeFile(filePath string, wg *sync.WaitGroup, data <-chan string) {
    defer wg.Done()

    // 使用互斥锁保护文件写入
    lock := new(sync.Mutex)

    file, err := os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    for dataString := range data {
        lock.Lock()
        _, err = file.WriteString(dataString + "\n")
        if err != nil {
            fmt.Println(err)
            continue
        }
        lock.Unlock()
    }
}

func main() {
    // 创建一个容量为 10 的管道
    ch := make(chan string, 10)

    // 等待组用于跟踪 goroutine
    var wg sync.WaitGroup

    filePath := "filename.txt"
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go writeFile(filePath, &wg, ch)
    }

    // 向管道写入数据，并停止管道以等待所有 goroutine 完成
    go func() {
        for i := 0; i < 100; i++ {
            ch <- fmt.Sprintf("Data point %d\n", i)
        }
        close(ch)
    }()

    wg.Wait()
}

Das obige ist der detaillierte Inhalt vonWie lese und schreibe ich Dateien gleichzeitig in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!