Atomic Operations in C

Atomic Operations in C Language with Examples

In this article, I will discuss Atomic Operations in C Language with Examples. Please read our previous article discussing Bounds Checking Interfaces in C with Examples. 

What are Atomic Operations in C?

Atomic operations in C programming are a set of instructions that are executed as a single, indivisible step. This means other threads or processes cannot interrupt an atomic operation once started. This is crucial in multi-threading environments to prevent race conditions, where multiple threads access and modify the same variable concurrently, leading to unpredictable results.

Key Concepts
  • Atomicity: Ensures that an operation completes without any interference from other threads.
  • Visibility: Changes made by one thread are visible to other threads.
  • Ordering: Ensures a sequence of operations is followed as expected.

Atomic Functions in C11 Standard: With the C11 standard, a new header file <stdatomic.h> was introduced. This provides a set of atomic operations and types that can be used to perform atomic operations on variables.

Types of Atomic Operations:
  • Load Operations: Read a value atomically.
  • Store Operations: Write a value atomically.
  • Read-Modify-Write Operations: Operations like atomic_fetch_add or atomic_compare_exchange_strong combine reading, modifying, and writing back a value atomically.

Memory Order: Atomic operations in C can specify memory order, which dictates the visibility of the operation to other threads. For example, memory_order_relaxed, memory_order_acquire, memory_order_release, etc.

Use in Multithreading: Atomic operations are essential in multithreaded applications to prevent race conditions, where two or more threads access shared data concurrently and cause unpredictable results.

Lock-Free Programming: Atomics enables lock-free programming, which can lead to more efficient multithreaded applications since they avoid the overhead of locking mechanisms.

Hardware Support: Atomic operations are often directly supported by hardware instructions, which makes them very efficient.

Examples of Atomic Operations:
  • atomic_load: Atomically loads and returns the value of the atomic variable.
  • atomic_store: Atomically stores a value in the atomic variable.
  • atomic_fetch_add: Atomically adds a number to the atomic variable and returns its old value.

Atomic Operations Examples in C

Below are examples illustrating the use of atomic operations in C. These examples assume the inclusion of the <stdatomic.h> header, which is part of the C11 standard.

Example: Atomic Load and Store

This example demonstrates simple atomic load and store operations.

#include <stdatomic.h>
#include <stdio.h>

int main() {
    atomic_int atomicVar = ATOMIC_VAR_INIT(10);

    // Atomic store
    atomic_store(&atomicVar, 20);

    // Atomic load
    int value = atomic_load(&atomicVar);

    printf("The atomic variable's value is: %d\n", value);

    return 0;

Output: The atomic variable’s value is: 20

In this example, an atomic_int variable is initialized, a value is stored atomically using atomic_store, and then the value is read using atomic_load.

Example: Atomic Fetch Add

This example shows how to add to a variable atomically.

#include <stdatomic.h>
#include <stdio.h>

int main() {
    atomic_int counter = ATOMIC_VAR_INIT(0);

    // Atomically add 5
    atomic_fetch_add(&counter, 5);

    printf("Counter value after atomic addition: %d\n", atomic_load(&counter));

    return 0;

Output: Counter value after atomic addition: 5

Here, atomic_fetch_add is used to atomically add a value to the counter. The operation returns the old value of the counter, but this return value is ignored in the example.

Example: Atomic Compare and Exchange

This example uses atomic_compare_exchange_strong to update a value conditionally.

#include <stdatomic.h>
#include <stdio.h>

int main() {
    atomic_int controlVar = ATOMIC_VAR_INIT(100);
    int expected = 100;
    int desired = 200;

    // Atomic compare and exchange
    if (atomic_compare_exchange_strong(&controlVar, &expected, desired)) {
        printf("Value successfully changed to %d\n", atomic_load(&controlVar));
    } else {
        printf("Exchange failed. Current value is %d\n", expected);

    return 0;

Output: Value successfully changed to 200

In this example, atomic_compare_exchange_strong checks if controlVar is equal to expected (100). If it is, controlVar is set to desired (200). If not, expected is set to the current value of controlVar.

When to Use Atomic Operations in C?

Atomic operations in C are powerful for managing concurrent access to shared data in multithreaded programming. They are crucial in ensuring data integrity and preventing race conditions. Here are scenarios and guidelines on when to use atomic operations:

  • Managing Shared Variables in Multithreading: Use atomic operations when multiple threads need to read, modify, and update shared variables. Atomics ensures that these operations on shared data are performed as a single, indivisible step, thus preventing inconsistencies and race conditions.
  • Implementing Lock-Free Data Structures: In scenarios where you need efficient multithreading without the overhead of locks, atomic operations can be used to implement lock-free data structures. These structures are more scalable under high contention as they avoid the costs associated with lock-based synchronization.
  • Counter and Flag Updates: Atomic operations are ideal for safely incrementing counters or updating flags in a multithreaded environment. For example, maintaining a count of active threads or updating a status flag that multiple threads need to check.
  • Signal Handling: In situations where a signal handler modifies a variable that is also accessed by other parts of the program, atomic operations can be used to ensure the integrity of these variable modifications.
  • Implementing Thread-Safe Singleton Patterns: When implementing a singleton pattern in a multithreaded environment, atomic operations can be used to ensure that the singleton instance is initialized only once.
  • Ordering Memory Operations: Atomic operations with specific memory orders (like memory_order_acquire and memory_order_release) can be used to enforce ordering constraints on memory operations, which is critical in multithreaded programs for maintaining consistency and avoiding memory reordering issues.
  • Synchronization Between Threads: Atomics can be used for simple synchronization tasks between threads, such as signaling a thread to proceed or waiting for a condition without involving heavy synchronization primitives like mutexes or condition variables.
  • Performance-Critical Sections: In performance-critical sections of code, where the overhead of locking mechanisms is too costly, atomic operations provide an efficient alternative for ensuring thread safety.
  • Inter-Thread Communication: For simple inter-thread communication, such as passing a single piece of data between threads, atomics can be a lightweight solution compared to more complex synchronization mechanisms.
Advantages and Disadvantages of Atomic Operations in C

Atomic operations in C, as in other programming languages, offer specific advantages and disadvantages, particularly in the context of multi-threaded programming. Understanding these can help you decide when and how to use them effectively.

Advantages of Atomic Operations in C:
  • Thread Safety: Atomic operations ensure that a variable is safely read or modified by one thread at a time, preventing race conditions.
  • Performance: They can be more efficient than synchronization mechanisms like mutexes, especially for simple operations, as they often translate to single-machine instructions and do not require context switching.
  • Simplicity: For simple operations like incrementing a counter or toggling a flag, atomic operations can be simpler to use and understand than other concurrency control mechanisms.
  • Lock-Free Programming: They enable lock-free algorithms, which can improve performance by reducing contention and deadlock risks.
  • Ordering Guarantees: Atomic operations provide guarantees about ordering operations, which is crucial in multi-threading, where the order of execution can be non-deterministic.
  • Consistency and Predictability: In multi-threaded applications, they provide a consistent view of memory across different threads, leading to predictable behavior.
Disadvantages of Atomic Operations in C:
  • Complexity: Properly understanding and using atomic operations requires a good grasp of memory models and concurrency, which can be complex and error-prone.
  • Limited Scope: Atomic operations are generally limited to simple operations. Complex operations or critical sections still require traditional locking mechanisms.
  • Performance Overhead: While faster than locks for simple operations, atomic operations can still have significant performance overhead, especially on weakly ordered memory models requiring memory fences.
  • Portability Issues: The behavior and performance of atomic operations can vary between hardware architectures and compilers, potentially leading to portability issues.
  • Overuse Pitfalls: Overusing atomic operations, especially in cases where higher-level abstractions are more appropriate, can lead to maintainability issues and performance bottlenecks.
  • Scalability Limits: In highly contended scenarios, the performance of atomic operations can degrade, limiting scalability.

In the next article, I will discuss Advanced C Concepts. In this article, I explain Atomic Operations in C Language with Examples. I hope you enjoy this Atomic Operations in C Language with Examples article. I would like to have your feedback. Please post your feedback, questions, or comments about this article.

Leave a Reply

Your email address will not be published. Required fields are marked *