golang文件读写加锁

在Golang中，文件读写操作是常见的任务之一。在多个goroutine同时读写同一个文件时，可能会引发竞态条件，导致数据的不一致性和错误。为了解决这个问题，我们可以使用互斥锁来保证线程安全的文件读写操作。

使用sync包实现文件读写加锁

在Golang中，我们可以使用sync包提供的Mutex类型来实现互斥锁。通过对文件读写操作前后分别加锁和解锁，我们可以确保只有一个goroutine能够访问文件。

首先，我们需要创建一个全局的互斥锁：

var fileLock sync.Mutex

接下来，我们可以在文件读写操作前后分别加锁和解锁：

func readFromFile() {
    fileLock.Lock()
    defer fileLock.Unlock()

    // 文件读取操作
}

func writeToFile(data []byte) {
    fileLock.Lock()
    defer fileLock.Unlock()

    // 文件写入操作
}

并发读取文件的例子

假设我们有一个读取文件的函数，它会从指定的文件中读取数据，并将结果返回：

func readFile(filename string) ([]byte, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    data, err := ioutil.ReadAll(file)
    if err != nil {
        return nil, err
    }

    return data, nil
}

如果我们需要并发地读取多个文件，可以使用goroutine来实现：

func readFiles(filenames []string) ([]string, error) {
    var wg sync.WaitGroup
    var mu sync.Mutex
    var results []string
    var errors []error

    for _, filename := range filenames {
        wg.Add(1)

        go func(filename string) {
            defer wg.Done()

            data, err := readFile(filename)
            if err != nil {
                mu.Lock()
                errors = append(errors, err)
                mu.Unlock()
                return
            }

            mu.Lock()
            results = append(results, string(data))
            mu.Unlock()
        }(filename)
    }

    wg.Wait()

    if len(errors) > 0 {
        return nil, errors[0]
    }

    return results, nil
}

并发写入文件的例子

假设我们有一个写入文件的函数，它会将指定的数据写入到指定的文件中：

func writeFile(filename string, data []byte) error {
    file, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer file.Close()

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

    return nil
}

如果我们需要并发地写入多个文件，可以使用goroutine来实现：

func writeFiles(filenames []string, data []byte) error {
    var wg sync.WaitGroup
    var mu sync.Mutex
    var errors []error

    for _, filename := range filenames {
        wg.Add(1)

        go func(filename string) {
            defer wg.Done()

            err := writeFile(filename, data)
            if err != nil {
                mu.Lock()
                errors = append(errors, err)
                mu.Unlock()
            }
        }(filename)
    }

    wg.Wait()

    if len(errors) > 0 {
        return errors[0]
    }

    return nil
}

通过使用sync包提供的互斥锁，我们可以实现安全的文件读写操作。无论是并发读取还是并发写入，我们都可以确保同一时间只有一个goroutine访问文件，避免了竞态条件和数据不一致性的问题。

在实际的开发中，我们还可以根据具体的需求，结合其他的并发原语来实现更复杂的文件读写加锁场景。比如，使用sync包提供的RWMutex类型来实现读写锁，允许多个goroutine同时进行读取操作，但只允许一个goroutine进行写入操作。