CKTIS / C
cnd_wait — fonction d’attente C23
`cnd_wait(cond, mtx)` de `<threads.h>` déverrouille atomiquement le `mtx` détenu et bloque jusqu’à un signal, un broadcast ou un déblocage non spécifié. Avant de revenir, elle verrouille de nouveau `mtx` ; résultat : `thrd_success` ou `thrd_error`.
Version : C23
Syntaxe
int cnd_wait(cnd_t *cond, mtx_t *mtx);cnd_wait(cond, mtx) de <threads.h> déverrouille atomiquement le mtx détenu et bloque jusqu’à un signal, un broadcast ou un déblocage non spécifié. Avant de revenir, elle verrouille de nouveau mtx ; résultat : thrd_success ou thrd_error.
L’exemple lance un worker qui fixe waiting, attend le prédicat protégé ready, puis lit payload après le signal. 1 42 confirme la réussite de cnd_wait, la reprise du mutex et la visibilité des données protégées par ce même mutex.
L’appelant doit déjà détenir mtx et les deux pointeurs doivent viser des objets vivants correctement initialisés. Les notifications ne sont pas mises en file et un réveil ne prouve pas le prédicat ; testez-le en boucle et, après une erreur, n’utilisez pas les données comme après une attente réussie.
Exemples
#include <stdatomic.h>
#include <stdio.h>
#include <threads.h>
static mtx_t mutex;
static cnd_t condition;
static atomic_int waiting;
static int ready;
static int payload;
static int observed;
static int worker(void *unused) {
(void)unused;
if (mtx_lock(&mutex) != thrd_success) return 1;
atomic_store(&waiting, 1);
while (!ready) {
if (cnd_wait(&condition, &mutex) != thrd_success) {
mtx_unlock(&mutex);
return 1;
}
}
observed = payload;
return mtx_unlock(&mutex) == thrd_success ? 0 : 1;
}
int main(void) {
if (mtx_init(&mutex, mtx_plain) != thrd_success) return 1;
if (cnd_init(&condition) != thrd_success) {
mtx_destroy(&mutex);
return 1;
}
thrd_t thread;
if (thrd_create(&thread, worker, NULL) != thrd_success) return 1;
while (!atomic_load(&waiting)) thrd_yield();
if (mtx_lock(&mutex) != thrd_success) return 1;
payload = 42;
ready = 1;
if (cnd_signal(&condition) != thrd_success) return 1;
if (mtx_unlock(&mutex) != thrd_success) return 1;
int worker_result;
if (thrd_join(thread, &worker_result) != thrd_success) return 1;
printf("%d %d\n", worker_result == 0, observed);
cnd_destroy(&condition);
mtx_destroy(&mutex);
return 0;
}
Résultat
1 42
L’exemple lance un worker qui fixe `waiting`, attend le prédicat protégé `ready`, puis lit `payload` après le signal. `1 42` confirme la réussite de `cnd_wait`, la reprise du mutex et la visibilité des données protégées par ce même mutex.