std::atomic

Learn atomic operations with std::atomic.

std::atomic

std::atomic<T> holds a shared T value without a data race. All reads and writes are indivisible; only one operation happens at a time. The syntax is std::atomic<int> a{0};.

Atomic is faster than a mutex because it makes no system call; most of the time it runs as a single CPU instruction. load() reads, store(v) writes. Shortcuts like a = 5; and int x = a; also become atomic operations automatically. Atomic is ideal for small shared data such as counters and flags.

load and store

To read an atomic value use a.load(); to write use a.store(v). This explicit form makes the read/write intent clear. The shortcut also works: int x = a; equals x = a.load();; a = 5; equals a.store(5);.

The is_lock_free() member tells whether operations are truly atomic at the hardware level. When it returns true no mutex is used; when false a hidden mutex lies underneath. For most basic types (int, bool, pointer) it returns true; for large structs it may return false.

Exercise store and load

Create std::atomic<int> a{0};. Write a value with a.store(5); and read it with std::cout << a.load();. Include the <atomic> header.

Show example solution

#include <iostream>
#include <atomic>

int main() {
    std::atomic<int> a{0};
    a.store(5);
    std::cout << a.load();
    return 0;
}

Test yourself

What does std::atomic prevent?
- Data races
- Memory leaks
- Exceptions
- Thread count
Show answer

Data races — std::atomic prevents data races on a shared value.

Complete the store line

std::atomic<int> a{0};
____(5);
std::cout << a.load();

Show answer

std::atomic<int> a{0};
a.store(5);
std::cout << a.load();

Match each expression to its role

a.load()

Atomic read
a.store(v)

Atomic write
std::atomic<int>

Atomic int declaration
a.is_lock_free()

Is lock-free?

Next lesson: memory_order

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies