Why did you use Mutex instead of Atomic for the counter?

The choice between Mutex and Atomic for a counter depends on the operation requirements and context:

• Atomic operations (e.g., atomic.AddInt32) provide low-level, fast, and non-blocking synchronization for simple operations on variables (increment, decrement).

• Mutex (mutual exclusion) locks access to a critical section, allowing more complex operations to be performed atomically, including multiple actions or logic that cannot be reduced to a single atomic instruction.

Reasons to use Mutex instead of Atomic for a counter:

1. If the increment is part of more complex logic, such as checking and modifying multiple variables simultaneously.
2. If data consistency needs to be ensured across multiple related operations.
3. If Atomic does not support the required data type or operations.

Example:

var count int
var mu sync.Mutex

func increment() {
    mu.Lock()
    defer mu.Unlock()
    count++
    // Additional logic requiring atomicity
}

Thus, Mutex provides more versatile control, albeit with overhead for locking, whereas Atomic is suitable for simple, fast operations.