Concurrency and Parallelism

Concurrency Control (Mutexes, Atomic Operations)

Effective concurrency control is critical for writing safe and performant concurrent programs. This section explores the key mechanisms provided by Go for managing shared state and ensuring correct program behavior: mutexes and atomic operations.

1. Understanding Race Conditions

1. Definition:

   • Race conditions occur when the behavior of a program depends on the relative timing of events such as the order of execution of goroutines.
   • They often lead to unpredictable and erroneous outcomes.

2. Example of Race Condition:

   go
   var counter int
   
   func increment() {
       counter++
   }
   
   func main() {
       for i := 0; i < 1000; i++ {
           go increment()
       }
       time.Sleep(time.Second)
       fmt.Println("Final counter value:", counter)
   }
   

   • In this example, multiple goroutines increment the counter variable concurrently, leading to a race condition.

2. Using Mutexes

1. Introduction to Mutexes:

   • A Mutex (mutual exclusion) is a synchronization primitive that ensures only one goroutine can access a critical section of code at a time.

2. Basic Mutex Example:

   go
   var (
       counter int
       mu      sync.Mutex
   )
   
   func increment() {
       mu.Lock()
       counter++
       mu.Unlock()
   }
   
   func main() {
       for i := 0; i < 1000; i++ {
           go increment()
       }
       time.Sleep(time.Second)
       fmt.Println("Final counter value:", counter)
   }
   

3. Types of Mutexes:

   • sync.Mutex: Provides basic mutual exclusion.
   • sync.RWMutex: Allows multiple readers or one writer at a time, useful for scenarios where reads are more frequent than writes.

4. Using RWMutex:

   go
   var (
       counter int
       rwMu    sync.RWMutex
   )
   
   func readCounter() int {
       rwMu.RLock()
       defer rwMu.RUnlock()
       return counter
   }
   
   func writeCounter() {
       rwMu.Lock()
       counter++
       rwMu.Unlock()
   }
   
   func main() {
       for i := 0; i < 1000; i++ {
           go writeCounter()
       }
       time.Sleep(time.Second)
       fmt.Println("Final counter value:", readCounter())
   }
   

3. Atomic Operations

1. Introduction to Atomic Operations:

   • Atomic operations are low-level operations that are performed as a single, indivisible step, ensuring consistency without the need for mutexes.
   • The sync/atomic package provides functions for atomic operations on various types.

2. Basic Atomic Operation Example:

   go
   var counter int64
   
   func increment() {
       atomic.AddInt64(&counter, 1)
   }
   
   func main() {
       for i := 0; i < 1000; i++ {
           go increment()
       }
       time.Sleep(time.Second)
       fmt.Println("Final counter value:", atomic.LoadInt64(&counter))
   }
   

3. Common Atomic Functions:

   • atomic.AddInt32 / atomic.AddInt64: Atomically adds a value.
   • atomic.LoadInt32 / atomic.LoadInt64: Atomically loads a value.
   • atomic.StoreInt32 / atomic.StoreInt64: Atomically stores a value.
   • atomic.CompareAndSwapInt32 / atomic.CompareAndSwapInt64: Atomically compares and swaps values.

4. Using Compare and Swap (CAS):

   go
   var counter int64
   
   func compareAndSwap(old, new int64) bool {
       return atomic.CompareAndSwapInt64(&counter, old, new)
   }
   
   func main() {
       old := atomic.LoadInt64(&counter)
       new := old + 1
       if compareAndSwap(old, new) {
           fmt.Println("Counter updated to:", new)
       } else {
           fmt.Println("Counter update failed")
       }
   }
   

4. Best Practices for Concurrency Control

1. Minimize Critical Sections:

   • Keep the code within critical sections (protected by mutexes) as short as possible to reduce contention.

2. Prefer Atomic Operations for Simple Counters:

   • Use atomic operations for simple counters or flags as they are faster and less prone to contention than mutexes.

3. Use RWMutex for Read-Heavy Workloads:

   • If your workload has significantly more reads than writes, use sync.RWMutex to allow multiple concurrent readers while still ensuring mutual exclusion for writers.

4. Avoid Deadlocks:

   • Ensure that locks are always acquired and released in the same order to prevent deadlocks.
   • Use defer to release locks to avoid forgetting to unlock in complex code paths.

5. Profile and Monitor:

   • Use Go's race detector (go run -race) to catch race conditions during development.
   • Profile your application to identify and address bottlenecks related to locking.

5. Example: Combining Mutexes and Atomic Operations

go
type Counter struct {
    mu    sync.Mutex
    value int64
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int64 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

func (c *Counter) AtomicIncrement() {
    atomic.AddInt64(&c.value, 1)
}

func (c *Counter) AtomicValue() int64 {
    return atomic.LoadInt64(&c.value)
}

func main() {
    var c Counter

    // Use mutex-protected increment
    for i := 0; i < 1000; i++ {
        go c.Increment()
    }
    time.Sleep(time.Second)
    fmt.Println("Mutex Counter value:", c.Value())

    // Use atomic increment
    for i := 0; i < 1000; i++ {
        go c.AtomicIncrement()
    }
    time.Sleep(time.Second)
    fmt.Println("Atomic Counter value:", c.AtomicValue())
}

By mastering mutexes and atomic operations, you can effectively manage concurrency in your Go applications, ensuring safe and efficient access to shared resources. These tools help you avoid race conditions and ensure correct program behavior in a concurrent environment.