Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C

atomic_thread_fence — fonction de barrière C23

`atomic_thread_fence(order)` établit une barrière mémoire sans lire ni écrire un objet atomique précis. Relaxed est sans effet ; consume/acquire donne une barrière acquire, release une release, acq_rel les deux, et seq_cst participe en plus à l’ordre séquentiellement cohérent. Elle ne renvoie rien.

Version : C23

Syntaxe

void atomic_thread_fence(memory_order order);

atomic_thread_fence(order) établit une barrière mémoire sans lire ni écrire un objet atomique précis. Relaxed est sans effet ; consume/acquire donne une barrière acquire, release une release, acq_rel les deux, et seq_cst participe en plus à l’ordre séquentiellement cohérent. Elle ne renvoie rien.

Une barrière peut relier des données ordinaires via un marqueur atomique séparé. Dans l’exemple, le producteur écrit payload = 42, exécute une barrière release puis un store relaxed dans ready ; le consommateur lit ce store en relaxed, exécute une barrière acquire et affiche 42 sans course.

La barrière seule ne transfère aucune valeur et ne synchronise aucun thread : il faut la chaîne définie par C23 entre une modification atomique et un load qui lit cette valeur, ou la variante barrière-opération correspondante. Si le load ne lit pas le bon store, payload n’est pas protégé. Une barrière relaxed ne corrige rien ; seq_cst inutile peut coûter plus que acquire/release.

Exemples

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

static int payload;
static atomic_int ready = 0;

static int writer(void *unused) {
    (void)unused;
    payload = 42;
    atomic_thread_fence(memory_order_release);
    atomic_store_explicit(&ready, 1, memory_order_relaxed);
    return 0;
}

static int reader(void *unused) {
    (void)unused;
    while (!atomic_load_explicit(&ready, memory_order_relaxed)) thrd_yield();
    atomic_thread_fence(memory_order_acquire);
    printf("%d\n", payload);
    return 0;
}

int main(void) {
    thrd_t producer, consumer;
    if (thrd_create(&consumer, reader, NULL) != thrd_success) return 1;
    if (thrd_create(&producer, writer, NULL) != thrd_success) return 1;
    thrd_join(producer, NULL);
    thrd_join(consumer, NULL);
    return 0;
}

Résultat

42

Une barrière peut relier des données ordinaires via un marqueur atomique séparé. Dans l’exemple, le producteur écrit `payload = 42`, exécute une barrière release puis un store relaxed dans `ready` ; le consommateur lit ce store en relaxed, exécute une barrière acquire et affiche `42` sans course.

Sources