std::atomic c++11

atomic: As its name, its atomic in nature that mean it offers operations that are guaranteed as mutex protected in critical section. It will be used to provide the concurrent access to global data from multiple threads without using mutex. Example: Write/Read the global variable and it is accessed by multiple threads.

With atomic:

//Global Variable
std::atomic<bool> bvar(false);
//Inside thread
bvar.store(true)

Without atomic:

//Global Variable
bool bvar = false;
std::mutex m;
//Inside thread
{
    std::lock_guard<std::mutex> lg(m);
    bvar=true;
}

Sample Code with example:

/*
Program: Atomic 
Author: Alpha Master
Date: 6 Feb 2021
*/

//Header File
#include<iostream>
#include<thread>
#include<atomic>
#include<chrono>

//Global Variable
int gValue;

//Atomic variable
std::atomic<bool> g_ab_ready(false);

//Reader Thread
void ReadThread()
{
    while(!g_ab_ready.load())
    {
        std::cout<<"!!!Waiting, variable is NOT ready"<<std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    //Go the value
    std::cout<<"Got the value:"<<gValue<<std::endl;
}

//Writer Thread
void WriteThread()
{
    //Write the value
    gValue = 50;
    std::cout<<"Wrote the value, make true to atomic"<<std::endl;
    g_ab_ready.store(true);
}

int main()
{
    std::cout<<"Atomic Functionality"<<std::endl;
	
    //Thread 1 and its joinable
    std::thread t1(ReadThread);
   
    //Thread 2 and its also joinable
    std::thread t2(WriteThread);

    std::cout<<"Main thread is Waiting for Child thread"<<std::endl;
    t1.join();
    t2.join();

    return 0;
};

Output:

Atomic Functionality
!!!Waiting, variable is NOT ready
Main thread is Waiting for Child thread
Wrote the value, make true to atomic
Got the value:50