What Are Useful Atomic Load And Store Operations In C++?

The concurrency support library in modern C++ is designed to solve problems in multi-thread operations. Since the C++11 standard, this library includes built-in support for threads (std::thread) with atomic operations (std::atomic). In this post, we explain what two atomic operations that can be used with std::atomic types, we explain what are atomic load and store operations.

What is atomic (std::atomic) in C++?

C++11 adds atomic types and operations to the standard. Atomic types and operations provide a way of writing multi-threaded applications without using locks. In modern C++, the std::atomic<> template class is defined in the <atomic> header and it can be used to wrap other types to do atomic operations on that type. When a thread writes to an atomic object another thread can read from it. Every instantiation and full specialization of the std::atomic template defines an atomic type.

Atomic types ensure any read or write operation synchronizes as part of multi-thread operations, (i.e. using these types in std::thread). They work well on any type that is trivially copyable types which means it has at least one eligible copy constructor, move constructor, copy assignment operator, or move assignment operator and has non-deleted trivial destructor.

Here is a simple syntax for the atomic declaration:

Here is a simple std::atomic example:

Atomic operations are operations one of the atomic types (std::atomic objects) in the atomic library that allows lockless concurrent programming. These operations are good in data races and these objects are free of data races. Different atomic operations can be done on the same atomic object in their sync.

std::atomic has many features to be used in atomic operations, i.e. load, store, operator=, wait, exchange, is_lock_free, etc. Let’s see these load and store operations now.

What are atomic load and store operations in C++?

Atomic load and store operations are load, atomic_load, atomic_load_explicit, store, atomic_store, atomic_store_explicit. Now let’s see how we can use these atomic operations in multi-threading operations.

How to use atomic load in C++?

The atomic load is an atomic operation that returns the value contained in that atomic object. Here is the syntax,

In example, you can obtain the value pointed by object with std::atomic::load().

or we can use with memory order,

Using load with memory order specifies how memory accesses are to be ordered in atomic load operation. This memory order types are defined in atomic library, here are permitted memory orders for atomic load,

•     memory_order_relaxed
•     memory_order_consume
•     memory_order_acquire 
•     memory_order_seq_cst

How to use std::atomic_load in modern C++?

The atomic_load is an atomic operation that returns the value contained in that atomic object. Here is the syntax,

and here is the simplified example,

How to use std::atomic_load_explicit in modern C++?

We can use atomic_load_explicit with memory order. Here are the permitted memory synchronization orders for std::atomic_load_explicit:

• std::memory_order_relaxed 
• std::memory_order_consume
• std::memory_order_acquire
• std::memory_order_seq_cst

How to use atomic store in modern C++?

The atomic store is an atomic operation that atomically replaces the current value of atomic object with a non atomic value. Here is the general syntax for it,

here is an example to using std::store with an object parameter,

here is an example to using std::store with object and memory order parameters,

We can use store with memory order. Here are the permitted memory synchronization orders for atomic store:

• std::memory_order_relaxed 
• std::memory_order_release
• std::memory_order_seq

How to use atomic_store in modern C++

The atomic_store is an atomic operation that replaces the value to the atomic object. Here is the syntax,

and here is the simplified example,

How to use atomic_store_explicit in modern C++?

We can use atomic_store_explicit with memory order. Here are the permitted memory synchronization orders are for std::atomic_store_explicit are:

• std::memory_order_relaxed 
• std::memory_order_release
• std::memory_order_seq

In addition to these load and store templates, there are std::atomic_load_explicit and std::atomic_store_explicit. Note that, there are other atomic operations in atomic library. Every operation on these atomic types are called as atomic operation. For more information on this feature, see Atomic operations Proposal document.

Is there a full example of load and store atomic operations in C++?

Here is a full example about different types of load and store atomic operations in modern C++,

C++ Builder is the easiest and fastest C and C++ IDE for building simple or professional applications on the Windows, MacOS, iOS & Android operating systems. It is also easy for beginners to learn with its wide range of samples, tutorials, help files, and LSP support for code. RAD Studio’s C++ Builder version comes with the award-winning VCL framework for high-performance native Windows apps and the powerful FireMonkey (FMX) framework for cross-platform UIs.

There is a free C++ Builder Community Edition for students, beginners, and startups; it can be downloaded from here. For professional developers, there are Professional, Architect, or Enterprise version.

Please leave this field empty

Oh hi there 👋
It’s nice to meet you.

Sign up to receive awesome C++ content in your inbox, every day.

Email Address *

We don’t spam! Read our privacy policy for more info.

Check your inbox or spam folder to confirm your subscription.