Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/cpp/cpp-11-atomic-header/ below:

C++ 11 - <atomic> Header

Last Updated : 23 Jul, 2025

In C++11, the <atomic> header introduces a powerful mechanism for managing concurrent access to shared data in multithreaded applications. This header provides atomic types and operations that ensure safe access to variables, preventing data races and potential issues in multithreaded code. In this article, we'll explore the concept of <atomic> in C++11, along with proper examples and comments to illustrate its usage.

In multithreaded programs, multiple threads often access and modify shared data simultaneously, which can lead to data races and unpredictable behavior. <atomic> solves this problem by providing atomic operations allowing threads to access and modify variables safely, without explicit locks or synchronization mechanisms.

In atomic operation, concurrent data access is regulated by a memory model for which the behavior is well-defined if one thread tries to access the data that another thread is currently accessing.

std::atomic <type> var_name;

where,

• type: the type of variable that can be of any primitive data type such as int, bool, char, etc.
• var_name: name of the atomic variable.

Atomic operations are the operations that can be done on the std::atomic type and the <atomic> header provides some functions to perform these atomic operations.

S. No.

Function

1

load()

2

store()

3

exchange()

4

wait()

5

notify_one()

6

notify_all()

7

fetch_add()

8

fetch_sub()

9

fetch_and()

10

fetch_or()

11

fetch_xor()

Let's explore some examples to understand how <atomic> works in practice.

std::atomic can be used with various data types for atomic operations. Let's use it with integers:

// C++ Program to illustrate the usage of <atomic> Header
#include <atomic>
#include <iostream>
#include <thread>
using namespace std;

atomic<int> counter(0); // Atomic integer

void increment_counter(int id)
{
    for (int i = 0; i < 100000; ++i) {
        // Increment counter atomically
        counter.fetch_add(1);
    }
}

int main()
{
    thread t1(increment_counter, 1);
    thread t2(increment_counter, 2);

    t1.join();
    t2.join();

    cout << "Counter: " << counter.load() << std::endl;

    return 0;
}

Output

Counter: 200000

A std::atomic_flag is a simple atomic boolean type that can be used as a lock-free flag. It is a specialization of atomic<bool> type that is guaranteed to be always lock-free.

It provides the following methods for atomic operations:

S. No.

Method

1

test()

2

test_and_set()

3

clear()

// C++ Program to illustrate the usage of <atomic> Header
#include <atomic>
#include <iostream>
#include <thread>
using namespace std;

// Initialize atomic flag
atomic_flag flag = ATOMIC_FLAG_INIT;

void thread_function(int id)
{
    for (int i = 0; i < 5; ++i) {
        while (flag.test_and_set(memory_order_acquire)) {
        }
        // Acquire lock
        cout << "Thread " << id << " is running." << endl;
        flag.clear(memory_order_release); // Release lock
    }
}

// driver code
int main()
{
    thread t1(thread_function, 1);
    thread t2(thread_function, 2);

    t1.join();
    t2.join();

    return 0;
}

Output

Thread 1 is running.
Thread 1 is running.
Thread 1 is running.
Thread 1 is running.
Thread 1 is running.
Thread 2 is running.
Thread 2 is running.
Thread 2 is running.
Thread 2 is running.
Thread 2 is running.

Explanation:

• We use std::atomic_flag as a lock to ensure that only one thread can enter the critical section at a time.
• test_and_set sets the flag to true (acquire lock) atomically, and clear resets it (release lock).
• The memory order parameters (std::memory_order_acquire and std::memory_order_release) ensure proper synchronization.

For a deeper understanding of <atomic>, you can refer to the following GeeksforGeeks articles:

• Atomic Operations in OS
• Atomic Operations

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4