How Can I Safely Collect Data from Multiple Go Threads While Preventing Race Conditions?

Safe Data Collection from Multiple Threads in Go

Concurrently accessing shared data across multiple threads without proper synchronization can lead to undefined behavior in Go. This is especially critical for scenarios involving both read and write operations.

Concurrent Access Risks

In your case, multiple worker threads are running in parallel, while the main thread periodically seeks to collect values from these workers. If left unchecked, race conditions can arise, where multiple threads attempt to access the same data simultaneously, potentially corrupting it.

Synchronization Options

To prevent concurrent access issues, you need to employ synchronization mechanisms. One commonly used approach is channels, which facilitate secure data exchange between goroutines. However, in your case, channels may not be the most efficient option as you are seeking to retrieve data from the workers rather than having them send it proactively.

Mutex-Protected Data

A more suitable solution involves protecting the shared data structure using a synchronization primitive such as a sync.RWMutex. This lock ensures that only one thread can modify the data at a time while allowing multiple threads to access it concurrently for reading.

Implementation Example

Here's a simplified implementation using a sync.RWMutex:

type Worker struct {
    iterMu sync.RWMutex
    iter   int
}

func (w *Worker) Iter() int {
    w.iterMu.RLock()
    defer w.iterMu.RUnlock()
    return w.iter
}

func (w *Worker) setIter(n int) {
    w.iterMu.Lock()
    w.iter = n
    w.iterMu.Unlock()
}

In this example, the worker's Iter method acquires a read lock and returns the current iteration count. The setIter method acquires a write lock, updates the iteration count, and releases the lock.

Alternatively, you could use the sync/atomic package to provide atomic operations on an integer counter, eliminating the need for explicit locking:

type Worker struct {
    iter int64
}

func (w *Worker) Iter() int64 {
    return atomic.LoadInt64(&w.iter)
}

func (w *Worker) setIter(n int64) {
    atomic.StoreInt64(&w.iter, n)
}

By using proper synchronization techniques, you can safely collect data from multiple threads in Go, ensuring data integrity and preventing race conditions.

The above is the detailed content of How Can I Safely Collect Data from Multiple Go Threads While Preventing Race Conditions?. For more information, please follow other related articles on the PHP Chinese website!