How to solve the read-write lock conflict problem of concurrent files in Go language?

How to solve the read-write lock conflict problem of concurrent files in Go language?

In the Go language, we often encounter scenarios where we need to read and write a file at the same time, such as writing a log file concurrently. If not controlled, multiple goroutines may read and write the same file at the same time, resulting in conflicts, resulting in data loss or inconsistency.

In order to solve this problem, we can use read-write lock (sync.RWMutex) to protect the file. Read-write locks can allow multiple goroutines to perform read operations at the same time, but only allow one goroutine to perform write operations. Through read-write locks, we can ensure that other goroutines will not perform read or write operations while the write operation is in progress, thus avoiding conflicts.

The following is a sample code that shows how to use read-write locks to resolve read-write conflicts for concurrent files:

package main

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

type FileWriter struct {
    file   *os.File
    rwLock sync.RWMutex
}

func NewFileWriter(filename string) (*FileWriter, error) {
    file, err := os.OpenFile(filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
    if err != nil {
        return nil, err
    }

    return &FileWriter{
        file: file,
    }, nil
}

func (fw *FileWriter) Write(data []byte) error {
    fw.rwLock.Lock()
    defer fw.rwLock.Unlock()

    _, err := fw.file.Write(data)
    if err != nil {
        return err
    }

    return nil
}

func main() {
    writer, err := NewFileWriter("log.txt")
    if err != nil {
        fmt.Println("Failed to create file writer:", err)
        return
    }

    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(index int) {
            defer wg.Done()

            data := fmt.Sprintf("Data %d
", index)
            err := writer.Write([]byte(data))
            if err != nil {
                fmt.Println("Failed to write data:", err)
            }
        }(i)
    }

    wg.Wait()
    writer.file.Close()

    fmt.Println("File writing finished.")
}

In the above code, we define a FileWriter Structure, which contains a os.File object and a read-write lock. The NewFileWriter function is used to create a FileWriter object and open the specified file. The Write method is used to perform write operations, using read-write locks to ensure that only one goroutine performs write operations at the same time.

In the main function, we create a FileWriter object and start 10 goroutines to write data to the file at the same time. Through the read-write lock mechanism, these goroutines can safely write files concurrently, avoiding conflicts.

Note that we use the defer statement in each goroutine to release the write lock. This ensures that the lock is released correctly even if an error occurs during the write operation.

Finally, we use sync.WaitGroup to wait for all goroutines to complete and close the file.

By using read-write locks, we can correctly resolve read-write conflicts in concurrent files and ensure data integrity and consistency. Of course, read-write locks are not only suitable for file reading and writing, but also for other data structures that require concurrent access, and can provide coordination and synchronization capabilities between multiple goroutines.

The above is the detailed content of How to solve the read-write lock conflict problem of concurrent files in Go language?. For more information, please follow other related articles on the PHP Chinese website!