How Can I Prevent Data Races When Concurrently Reading and Writing Go Structs?

Concurrent Read and Write of Go Structs Without Explicit Locking

Concurrent access to shared data in Go can be a source of potential errors, such as data races. When access to a data structure is concurrent, i.e. multiple goroutines can access it at the same time, it's crucial to ensure that the data is read and written in a synchronized manner to avoid inconsistencies.

Concurrent Access to Structs

Consider the following Go struct Metadata:

type Metadata struct {
    mu  sync.RWMutex // ?
    key bool
}

As we can see, the Metadata struct contains a field key of type bool, and another field mu of type sync.RWMutex, which is an implementation of a read-write lock.

Data Races in Structs

If we create an instance of Metadata and allow multiple goroutines to concurrently read and write its fields, we might encounter data races. A data race occurs when multiple goroutines access the same data concurrently and at least one of them is performing a write operation.

The following code demonstrates concurrent read and write access to the Metadata struct without explicit locking:

func concurrentStruct() {
    m := new(Metadata)

    for i := 0; i < 100000; i++ {
        go func(metadata *Metadata) {
            for {
                readValue := metadata.key
                if readValue {
                    metadata.key = false
                }
            }
        }(m)

        go func(metadata *Metadata) {
            for {
                metadata.key = true
            }
        }(m)
    }

    select {}
}

In this code, we create a goroutine that reads and writes the key field concurrently. We use a select statement to block the main goroutine, allowing the concurrent goroutines to run. Using the go run -race command to run the program, we will get a warning indicating a DATA RACE.

However, the program continues to run without crashing. This is because the Go runtime has built-in concurrency checking, but it doesn't guarantee safe execution. In this case, the data race can lead to undefined behavior and incorrect results.

Resolving Data Races in Structs

To prevent data races when concurrently reading and writing to structs, we need to use proper locking mechanisms. One way is to use mutexes, as demonstrated in the following code:

func concurrentStructWithMuLock() {
    m := new(Metadata)

    go func(metadata *Metadata) {
        for {
            metadata.mu.Lock()
            readValue := metadata.key
            if readValue {
                metadata.key = false
            }
            metadata.mu.Unlock()
        }
    }(m)

    go func(metadata *Metadata) {
        for {
            metadata.mu.Lock()
            metadata.key = true
            metadata.mu.Unlock()
        }
    }(m)

    select {}
}

In this code, we've added a read-write lock to the Metadata struct and use mu.Lock() and mu.Unlock() to synchronize access to the key field. Running the program with go run -race will no longer generate any warnings, indicating that there are no data races.

The above is the detailed content of How Can I Prevent Data Races When Concurrently Reading and Writing Go Structs?. For more information, please follow other related articles on the PHP Chinese website!