C++ 11 - <atomic> Header

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.

What is <atomic> in C++11?

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.

Syntax of Atomic Variable

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

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.

Examples of std::atomic

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

Example 1

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

Atomic Flag

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:

Example 2: Atomic Flag

// 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.

Related Articles

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

• Atomic Operations in OS
• Atomic Operations

ayushi_awasthi_

Follow

Improve

Article Tags :

• C++
• Geeks Premier League
• C++ 11
• Geeks Premier League 2023

Practice Tags :

• CPP