¿Cómo usar variables atómicas en C?

— Función integrada:bool __atomic_always_lock_free (size_t size, void *ptr)
Esta función integrada devuelve verdadero si los objetos de size Los bytes siempre generan instrucciones atómicas sin bloqueo para la arquitectura de destino. size debe resolverse en una constante de tiempo de compilación y el resultado también se resuelve en una constante de tiempo de compilación.

ptr es un puntero opcional al objeto que se puede usar para determinar la alineación. Un valor de 0 indica que se debe usar la alineación típica. El compilador también puede ignorar este parámetro.

      if (_atomic_always_lock_free (sizeof (long long), 0))

Primitivos atómicos C11

http://en.cppreference.com/w/c/language/atomic

_Atomic const int * p1;  // p is a pointer to an atomic const int
const atomic_int * p2;   // same
const _Atomic(int) * p3; // same

Añadido en glibc 2.28. Probado en Ubuntu 18.04 (glibc 2.27) al compilar glibc desde la fuente:Múltiples bibliotecas glibc en un solo host Más tarde también probado en Ubuntu 20.04, glibc 2.31.

Ejemplo adaptado de:https://en.cppreference.com/w/c/language/atomic

principal.c

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

atomic_int acnt;
int cnt;

int f(void* thr_data)
{
    (void)thr_data;
    for(int n = 0; n < 1000; ++n) {
        ++cnt;
        ++acnt;
        // for this example, relaxed memory order is sufficient, e.g.
        // atomic_fetch_add_explicit(&acnt, 1, memory_order_relaxed);
    }
    return 0;
}

int main(void)
{
    thrd_t thr[10];
    for(int n = 0; n < 10; ++n)
        thrd_create(&thr[n], f, NULL);
    for(int n = 0; n < 10; ++n)
        thrd_join(thr[n], NULL);

    printf("The atomic counter is %u\n", acnt);
    printf("The non-atomic counter is %u\n", cnt);
}

Compilar y ejecutar:

gcc -ggdb3 -O0 -std=c99 -Wall -Wextra -pedantic -o main.out main.c -pthread
./main.out

Salida posible:

The atomic counter is 10000
The non-atomic counter is 8644

Es muy probable que el contador no atómico sea más pequeño que el atómico debido al acceso acelerado a través de subprocesos a la variable no atómica.

Análisis de desensamblaje en:¿Cómo empiezo subprocesos en C simple?