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

CKTIS / C

call_once — fonction de bibliothèque C23

`call_once(flag, func)` utilise un `once_flag` pour appeler `func` exactement une fois, lors du premier appel effectif avec cet objet, et ne renvoie rien. La fin de cet appel se synchronise avec tout autre appel du même drapeau : ceux déjà en cours et attendant `func`, ainsi que les appels ultérieurs.

Version : C23

Syntaxe

void call_once(once_flag *flag, void (*func)(void));

call_once(flag, func) utilise un once_flag pour appeler func exactement une fois, lors du premier appel effectif avec cet objet, et ne renvoie rien. La fin de cet appel se synchronise avec tout autre appel du même drapeau : ceux déjà en cours et attendant func, ainsi que les appels ultérieurs.

Elle assure une initialisation paresseuse sûre d’un état partagé. Dans l’exemple, deux threads appellent call_once, mais l’initialiseur n’incrémente son compteur qu’une fois et publie value = 42 ; après join, le résultat est 1 42.

Le drapeau doit être initialisé par ONCE_FLAG_INIT et rester le même objet ; ne le copiez ni ne le réinitialisez. func est de type void(void) et call_once ne renvoie aucun code d’erreur. Une implémentation avec __STDC_NO_THREADS__ peut omettre <threads.h> ; l’emploi récursif du même drapeau n’est pas portable.

Exemples

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

static once_flag initialization_flag = ONCE_FLAG_INIT;
static int initialization_count;
static int shared_value;

static void initialize_shared_value(void) {
    ++initialization_count;
    shared_value = 42;
}

static int worker(void *unused) {
    (void)unused;
    call_once(&initialization_flag, initialize_shared_value);
    return 0;
}

int main(void) {
    thrd_t first;
    thrd_t second;
    if (thrd_create(&first, worker, NULL) != thrd_success) return 1;
    if (thrd_create(&second, worker, NULL) != thrd_success) {
        thrd_join(first, NULL);
        return 1;
    }
    thrd_join(first, NULL);
    thrd_join(second, NULL);
    printf("%d %d\n", initialization_count, shared_value);
    return 0;
}

Résultat

1 42

Elle assure une initialisation paresseuse sûre d’un état partagé. Dans l’exemple, deux threads appellent `call_once`, mais l’initialiseur n’incrémente son compteur qu’une fois et publie `value = 42` ; après join, le résultat est `1 42`.

Sources