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 <p>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.</p><p>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.</p><h3 id="Resolving-Data-Races-in-Structs">Resolving Data Races in Structs</h3><p>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:</p><pre class="brush:php;toolbar:false">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!