CKTIS / C
cnd_broadcast — fonction de variable de condition C23
`cnd_broadcast(cond)` de `<threads.h>` débloque tous les threads bloqués sur cette variable de condition au moment de l’appel. Sans attente, elle ne fait rien ; elle renvoie `thrd_success` ou `thrd_error` si la requête ne peut être satisfaite.
Version : C23
Syntaxe
int cnd_broadcast(cnd_t *cond);cnd_broadcast(cond) de <threads.h> débloque tous les threads bloqués sur cette variable de condition au moment de l’appel. Sans attente, elle ne fait rien ; elle renvoie thrd_success ou thrd_error si la requête ne peut être satisfaite.
Dans l’exemple, deux attentes, le compteur arrived et le même mutex garantissent que les deux threads attendent. Le thread principal fixe le prédicat open et appelle cnd_broadcast ; après join, 1 2 confirme le succès et le passage des deux threads.
La notification n’est pas mémorisée : un broadcast antérieur à l’attente n’aide pas un thread ultérieur. Chaque réveillé doit reprendre le mutex, généralement à tour de rôle, et retester le prédicat en boucle car C23 autorise un déblocage pour une raison non spécifiée ; cond doit être un objet vivant issu d’un cnd_init réussi.
Exemples
#include <stdatomic.h>
#include <stdio.h>
#include <threads.h>
static mtx_t gate;
static cnd_t condition;
static atomic_int arrived;
static atomic_int awakened;
static int open;
static int waiter(void *unused) {
(void)unused;
if (mtx_lock(&gate) != thrd_success) return 1;
atomic_fetch_add(&arrived, 1);
while (!open) {
if (cnd_wait(&condition, &gate) != thrd_success) {
mtx_unlock(&gate);
return 1;
}
}
atomic_fetch_add(&awakened, 1);
return mtx_unlock(&gate) == thrd_success ? 0 : 1;
}
int main(void) {
if (mtx_init(&gate, mtx_plain) != thrd_success) return 1;
if (cnd_init(&condition) != thrd_success) {
mtx_destroy(&gate);
return 1;
}
thrd_t first;
thrd_t second;
if (thrd_create(&first, waiter, NULL) != thrd_success) return 1;
if (thrd_create(&second, waiter, NULL) != thrd_success) {
mtx_lock(&gate);
open = 1;
cnd_broadcast(&condition);
mtx_unlock(&gate);
thrd_join(first, NULL);
return 1;
}
while (atomic_load(&arrived) != 2) thrd_yield();
if (mtx_lock(&gate) != thrd_success) return 1;
open = 1;
int result = cnd_broadcast(&condition);
if (mtx_unlock(&gate) != thrd_success) return 1;
int first_result;
int second_result;
thrd_join(first, &first_result);
thrd_join(second, &second_result);
printf("%d %d\n", result == thrd_success && first_result == 0 && second_result == 0,
atomic_load(&awakened));
cnd_destroy(&condition);
mtx_destroy(&gate);
return 0;
}
Résultat
1 2
Dans l’exemple, deux attentes, le compteur `arrived` et le même mutex garantissent que les deux threads attendent. Le thread principal fixe le prédicat `open` et appelle `cnd_broadcast` ; après join, `1 2` confirme le succès et le passage des deux threads.