Concurrency support library

< c

C includes built-in support for threads, atomic operations, mutual exclusion, condition variables, and thread-specific storages.

These features are optionally provided:

  • if the macro constant __STDC_NO_THREADS__ is defined by the compiler, the header <threads.h> and all of the names provided in it are not provided;
  • if the macro constant __STDC_NO_ATOMICS__ is defined by the compiler, the header <stdatomic.h> and all of the names provided in it are not provided.


Defined in header <threads.h>
thrd_t implementation-defined complete object type identifying a thread
creates a thread
checks if two identifiers refer to the same thread
obtains the current thread identifier
suspends execution of the calling thread for the given period of time
yields the current time slice
terminates the calling thread
detaches a thread
blocks until a thread terminates
indicates a thread error status
a typedef of the function pointer type int(*)(void*), used by thrd_create

Atomic operations

Defined in header <stdatomic.h>
Operations on atomic types
indicates that the given atomic type is lock-free
(macro constant)
indicates whether the atomic object is lock-free
stores a value in an atomic object
reads a value from an atomic object
swaps a value with the value of an atomic object
swaps a value with an atomic object if the old value is what is expected, otherwise reads the old value
atomic addition
atomic subtraction
atomic bitwise OR
atomic bitwise exclusive OR
atomic bitwise AND
Flag type and operations
lock-free atomic boolean flag
sets an atomic_flag to true and returns the old value
sets an atomic_flag to false
initializes an existing atomic object
(C11)(deprecated in C17)(removed in C23)
initializes a new atomic object
(function macro)
initializes a new atomic_flag
(macro constant)
Memory synchronization ordering
defines memory ordering constraints
breaks a dependency chain for memory_order_consume
(function macro)
generic memory order-dependent fence synchronization primitive
fence between a thread and a signal handler executed in the same thread
Convenience type aliases
Typedef name Full type name
atomic_bool(C11) _Atomic _Bool
atomic_char(C11) _Atomic char
atomic_schar(C11) _Atomic signed char
atomic_uchar(C11) _Atomic unsigned char
atomic_short(C11) _Atomic short
atomic_ushort(C11) _Atomic unsigned short
atomic_int(C11) _Atomic int
atomic_uint(C11) _Atomic unsigned int
atomic_long(C11) _Atomic long
atomic_ulong(C11) _Atomic unsigned long
atomic_llong(C11) _Atomic long long
atomic_ullong(C11) _Atomic unsigned long long
atomic_char8_t(C23) _Atomic char8_t
atomic_char16_t(C11) _Atomic char16_t
atomic_char32_t(C11) _Atomic char32_t
atomic_wchar_t(C11) _Atomic wchar_t
atomic_int_least8_t(C11) _Atomic int_least8_t
atomic_uint_least8_t(C11) _Atomic uint_least8_t
atomic_int_least16_t(C11) _Atomic int_least16_t
atomic_uint_least16_t(C11) _Atomic uint_least16_t
atomic_int_least32_t(C11) _Atomic int_least32_t
atomic_uint_least32_t(C11) _Atomic uint_least32_t
atomic_int_least64_t(C11) _Atomic int_least64_t
atomic_uint_least64_t(C11) _Atomic uint_least64_t
atomic_int_fast8_t(C11) _Atomic int_fast8_t
atomic_uint_fast8_t(C11) _Atomic uint_fast8_t
atomic_int_fast16_t(C11) _Atomic int_fast16_t
atomic_uint_fast16_t(C11) _Atomic uint_fast16_t
atomic_int_fast32_t(C11) _Atomic int_fast32_t
atomic_uint_fast32_t(C11) _Atomic uint_fast32_t
atomic_int_fast64_t(C11) _Atomic int_fast64_t
atomic_uint_fast64_t(C11) _Atomic uint_fast64_t
atomic_intptr_t(C11) _Atomic intptr_t
atomic_uintptr_t(C11) _Atomic uintptr_t
atomic_size_t(C11) _Atomic size_t
atomic_ptrdiff_t(C11) _Atomic ptrdiff_t
atomic_intmax_t(C11) _Atomic intmax_t
atomic_uintmax_t(C11) _Atomic uintmax_t

Mutual exclusion

Defined in header <threads.h>
mtx_t mutex identifier
creates a mutex
blocks until locks a mutex
blocks until locks a mutex or times out
locks a mutex or returns without blocking if already locked
unlocks a mutex
destroys a mutex
defines the type of a mutex
Call once
calls a function exactly once

Condition variables

Defined in header <threads.h>
cnd_t condition variable identifier
creates a condition variable
unblocks one thread blocked on a condition variable
unblocks all threads blocked on a condition variable
blocks on a condition variable
blocks on a condition variable, with a timeout
destroys a condition variable

Thread-local storage

Defined in header <threads.h>
thread local type macro
(keyword macro)
tss_t thread-specific storage pointer
maximum number of times destructors are called
(macro constant)
tss_dtor_t function pointer type void(*)(void*), used for TSS destructor
creates thread-specific storage pointer with a given destructor
reads from thread-specific storage
write to thread-specific storage
releases the resources held by a given thread-specific pointer

Reserved identifiers

In future revisions of the C standard:

  • function names, type names, and enumeration constants that begin with either cnd_, mtx_, thrd_, or tss_, and a lowercase letter may be added to the declarations in the <threads.h> header;
  • macros that begin with ATOMIC_ and an uppercase letter may be added to the macros defined in the <stdatomic.h> header;
  • typedef names that begin with either atomic_ or memory_, and a lowercase letter may be added to the declarations in the <stdatomic.h> header;
  • enumeration constants that begin with memory_order_ and a lowercase letter may be added to the definition of the memory_order type in the <stdatomic.h> header;
  • function names that begin with atomic_ and a lowercase letter may be added to the declarations in the <stdatomic.h> header.

Identifiers reserved for functions names are always potentially (since C23) reserved for use as identifiers with external linkage, while other identifiers list here are potentially (since C23) reserved when <stdatomic.h> is included.

Declaring, defining, or #undefing such an identifier results in undefined behavior if it is provided by the standard or implementation (since C23). Portable programs should not use those identifiers.


  • C17 standard (ISO/IEC 9899:2018):
  • 7.17 Atomics <stdatomic.h> (p: 200-209)
  • 7.26 Threads <threads.h> (p: 274-283)
  • 7.31.8 Atomics <stdatomic.h> (p: 332)
  • 7.31.15 Threads <threads.h> (p: 333)
  • C11 standard (ISO/IEC 9899:2011):
  • 7.17 Atomics <stdatomic.h> (p: 273-286)
  • 7.26 Threads <threads.h> (p: 376-387)
  • 7.31.8 Atomics <stdatomic.h> (p: 455-456)
  • 7.31.15 Threads <threads.h> (p: 456)

See also

GNU GCC Libc Manual: ISO-C-Mutexes