What are the differences between std::atomic and mutex in C++?

What are the differences between std::atomic and mutex in C++?

Both std::atomic and mutex are used for thread synchronization in C++, but they serve different purposes. std::atomic provides lock-free operations for single variables, allowing for safe concurrent access without the overhead of locking. In contrast, a mutex is used to protect a block of code or a resource, ensuring that only one thread can access it at a time.

When should I use std::atomic instead of a mutex?

You should use std::atomic when you need to perform simple operations on a single variable atomically, such as incrementing a counter. It's more efficient for these cases because it avoids the overhead of locking. Use a mutex when you need to protect more complex data structures or when multiple variables need to be accessed together.

Can you give an example of using std::atomic?

Sure! Here's a simple example:

#include <atomic>
#include <thread>

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

void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter++;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final counter value: " << counter.load() << std::endl;
}

This code safely increments the counter from two threads without using a mutex.

What are the performance implications of using mutex?

Using a mutex can introduce overhead due to locking and unlocking, which can lead to contention if multiple threads try to access the same resource simultaneously. This can slow down your program, especially if the critical section is large or if threads are frequently blocked. In contrast, std::atomic can provide better performance for simple operations.