Atomic Operations

The std::atomic class template in <atomic> provides atomic read and write operations. This allows you to share data between threads safely without using heavyweight locks.

compare_exchange_weak vs. compare_exchange_strong

These functions implement the Compare-and-Swap (CAS) primitive:

• compare_exchange_weak: Can fail spuriously even if the current value matches the expected value. However, it compiles to faster instructions on architectures like ARM and is preferred inside loops.
• compare_exchange_strong: Guarantees no spurious failures. It is preferred when CAS checks are performed once without a loop.

Code Walkthrough

A thread-safe lock-free counter and value-update loop using weak compare-and-swap.

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
std::atomic<int> g_counter(0);
void incrementCounter() {
    for (int i = 0; i < 1000; ++i) {
        g_counter.fetch_add(1, std::memory_order_seq_cst); // Thread-safe atomic increment
    }
}
// Lock-free updates to a maximum value
void updateMax(std::atomic<int>& maxVal, int val) {
    int current = maxVal.load();
    while (val > current && !maxVal.compare_exchange_weak(current, val)) {
        // current is updated automatically on failure
    }
}
int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) threads.emplace_back(incrementCounter);
    for (auto& t : threads) t.join();
std::cout << "Final Counter: " << g_counter.load() << std::endl;
    return 0;
}

Interview-Relevant Information