How do synchronization primitives such as mutexes and atomic operations differ in the context of ensuring safe access to data?

Mutex (mutual exclusion) and atomic operations are synchronization primitives used to ensure safe access to shared data in a multithreaded environment, but they work differently:

• Mutex is a lock that allows only one thread at a time to execute a critical section of code. If a thread has acquired the mutex, other threads wait for it to be released. This provides full protection but can lead to blocking and reduced performance.

• Atomic operations are operations that are performed as indivisible units at the processor level, without the possibility of interruption. They do not require locks and are usually faster than mutexes, but are limited to simple operations (e.g., increment, compare and swap).

Example of using an atomic operation in C++:

#include <atomic>

std::atomic<int> counter(0);

void increment() {
    counter.fetch_add(1, std::memory_order_relaxed);
}

Thus, mutexes are suitable for protecting complex critical sections, while atomic operations are used for simple data modifications without locks.