
<div class="image-550">
<img src="https://cdn.kahimyang.com/resources-24/cpp-logo.avif" alt="C++ std::atomic" loading="lazy" />
</div>
<h4>
What is std::atomic?
</h4>
<p>
std::atomic is a template class in the C++ Standard Library designed to provide atomic operations on variables. Atomic operations are operations that complete in a single step relative to other threads. This means that no other thread can see an intermediate state of the operation.
</p>
<h4>
Why Use std::atomic?
</h4>
<ul class="k-list">
<li>
<b>Performance</b>: Unlike mutexes, which can cause significant overhead due to locking and unlocking, std::atomic operations are usually implemented using low-level hardware instructions that are much faster.
</li>
<li>
<b>Simplicity</b>: std::atomic abstracts away the complexities of implementing lock-free algorithms, providing a simpler interface for developers.
</li>
<li>
<b>Safety</b>: By ensuring that operations on shared variables are atomic, std::atomic helps prevent race conditions and data corruption.
</li>
</ul>

<h4>
Basic Usage
</h4>
<p>
Here's a simple example demonstrating the use of std::atomic:
</p>
<pre style="font-size: 90%;">
<code class="language-cpp line-numbers normalize-whitespace" >
#include &lt;iostream>
#include &lt;atomic>
#include &lt;thread>
#include &lt;vector>

std::atomic&lt;int> counter(0);

void incrementCounter() {
    for (int i = 0; i &lt; 1000; ++i) {
        ++counter;
    }
}

int main() {
    std::vector&lt;std::thread> threads;
    for (int i = 0; i &lt; 10; ++i) {
        threads.emplace_back(incrementCounter);
    }
    for (auto& thread : threads) {
        thread.join();
    }

    std::cout &lt;&lt; "Final counter value: " &lt;&lt; counter.load() 
                           &lt;&lt; std::endl;

    return 0;
}
</code>
</pre>
<p>
In this example, we use std::atomic&lt;int> to create an atomic integer. Multiple threads increment this counter simultaneously, but thanks to std::atomic, the operations are safe from race conditions.
</p>
<p>
Besides basic types like int, std::atomic supports pointers and user-defined types. The user-defined type should be trivially copyable, meaning it should not have any complex constructors, destructors, or virtual functions.
</p>



Exploring C++ std:atomic: Memory Order & Atomic Operations