#include <stdatomic.h>
atomic-type ATOMIC_VAR_INIT(non-atomic-type val);
void atomic_init(volatile atomic-type *ptr, non-atomic-type val);

A static or thread-local [Why does thread-local even matter? It cannot be accessed by multiple threads anyway.] atomic variable is safely zero-initialized by default. Atomic variables can also be initialized explicitly at declaration with ATOMIC_VAR_INIT:

atomic_int obj = ATOMIC_VAR_INIT(10);

[: What's the use of a thread-local atomic?]

Atomic flags should be initialized with ATOMIC_FLAG_INIT:

atomic_flag obj = ATOMIC_FLAG_INIT;

To initialize at a point other than the declaration, use atomic_init:

atomic_int obj;
atomic_init(&obj, 10);

Automatic variables must be initialized with ATOMIC_VAR_INIT, ATOMIC_FLAG_INIT or atomic_init. Note that these three approaches do not prevent race conditions.

An operation on an atomic variable is safe to a limited degree from race conditions caused by multiple threads attempting to update the same variable. Modifications to atomic variables must be done through a limited set of generic functions and macros declared by <stdatomic.h>. In their declarations, atomic-type matches any atomic type. non-atomic-type matches the corresponding non-atomic type. atomic-modifying-type is the same, except when dealing with atomic pointer types, in which case, it is ptrdiff_t.

#include <stdatomic.h>

void atomic_store(volatile atomic-type *obj,
                  non-atomic-type value);
void atomic_store_explicit(volatile atomic-type *obj,
                           non-atomic-type value,
                           memory_order order);

#include <stdatomic.h>

non-atomic-type atomic_load(volatile atomic-type *obj);
non-atomic-type atomic_load_explicit(volatile atomic-type *obj,
                                    memory_order order);

#include <stdatomic.h>

non-atomic-type atomic_exchange(volatile atomic-type *obj,
                               non-atomic-type value);
non-atomic-type atomic_exchange_explicit(volatile atomic-type *obj,
                                        non-atomic-type value,
                                        memory_order order);

#include <stdatomic.h>

_Bool
atomic_compare_exchange_strong(volatile atomic-type *obj,
                                        non-atomic-type *expect,
                                        non-atomic-type value);
_Bool
atomic_compare_exchange_strong_explicit(volatile atomic-type *obj,
                                        non-atomic-type *expect,
                                        non-atomic-type value,
                                        memory_order success,
                                        memory_order failure);

_Bool
atomic_compare_exchange_weak(volatile atomic-type *obj,
                             non-atomic-type *expect,
                             non-atomic-type value);
_Bool
atomic_compare_exchange_weak_explicit(volatile atomic-type *obj,
                                      non-atomic-type *expect,
                                      non-atomic-type value,
                                      memory_order success,
                                      memory_order failure);

#include <stdatomic.h>

non-atomic-type atomic_fetch_add(volatile atomic-type *obj,
                               atomic-modifying-type value);
non-atomic-type atomic_fetch_sub(volatile atomic-type *obj,
                               atomic-modifying-type value);
non-atomic-type atomic_fetch_or(volatile atomic-type *obj,
                               atomic-modifying-type value);
non-atomic-type atomic_fetch_xor(volatile atomic-type *obj,
                               atomic-modifying-type value);
non-atomic-type atomic_fetch_and(volatile atomic-type *obj,
                               atomic-modifying-type value);

#include <stdatomic.h>

_Bool
atomic_flag_test_and_set(volatile atomic_flag *obj);
_Bool
atomic_flag_test_and_set_explicit(volatile atomic_flag *obj,
                                  memory_order order);

#include <stdatomic.h>

void atomic_flag_clear(volatile atomic_flag *obj);
void atomic_flag_clear_explicit(volatile atomic_flag *obj,
                                memory_order order);

#include <stdatomic.h>
_Bool atomic_is_lock_free(const volatile atomic-type *ptr);

Some atomic objects are lock-free. [But what does that mean?] You can determine whether an atomic object obj is lock-free by calling atomic_is_lock_free(&obj). Each of the macros ending in _LOCK_FREE expands to 2 if the corresponding type is always lock-free, 1 if sometimes, and 0 if never.

• ATOMIC_BOOL_LOCK_FREE informs about atomic_bool.
• ATOMIC_CHAR_LOCK_FREE informs about atomic_char, atomic_schar and atomic_uchar.
• ATOMIC_SHORT_LOCK_FREE informs about atomic_short and atomic_ushort.
• ATOMIC_INT_LOCK_FREE informs about atomic_int and atomic_uint.
• ATOMIC_LONG_LOCK_FREE informs about atomic_long and atomic_ulong.
• ATOMIC_LLONG_LOCK_FREE informs about atomic_llong and atomic_ullong.
• ATOMIC_WCHAR_T_LOCK_FREE informs about atomic_wchar_t.
• ATOMIC_CHAR16_T_LOCK_FREE informs about atomic_char16_t.
• ATOMIC_CHAR32_T_LOCK_FREE informs about atomic_char32_t.
• ATOMIC_POINTER_LOCK_FREE informs about all atomic pointer-to-object types.