Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::latch — attendere una sola volta che un contatore raggiunga zero

std::latch di <latch> consente ai thread di attendere che un contatore raggiunga zero. count_down() segnala il completamento di un’unità di lavoro, mentre wait() attende la fine del conto alla rovescia senza modificare il contatore.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <latch>
std::latch done{expected};
done.count_down();
done.wait();

std::latch è un meccanismo di sincronizzazione utilizzabile una sola volta, fornito da <latch>. Il suo costruttore imposta il contatore su expected, che deve soddisfare 0 <= expected && expected <= std::latch::max(). Il contatore rappresenta le segnalazioni ancora attese, che non provengono necessariamente da thread distinti. Una volta raggiunto lo zero, l’oggetto non può essere reimpostato né riutilizzato per un altro ciclo.

std::latch::count_down(update) sottrae update in modo atomico; il valore predefinito è 1. È richiesto 0 <= update e update non deve superare il valore corrente del contatore; quindi, non chiamare count_down() con il valore predefinito quando il contatore è già a zero. Questo metodo non attende le altre segnalazioni. std::latch::wait() non decrementa il contatore: la chiamata si blocca finché il contatore non raggiunge zero, oppure ritorna subito se è già a zero. Se mancano delle segnalazioni, l’attesa può proseguire indefinitamente.

In C++23, count_down() precede, nel senso della relazione strongly happens-before, il ritorno delle chiamate sbloccate sul latch. Questa garanzia non copre esplicitamente una chiamata a wait() che inizia dopo che il contatore ha raggiunto lo zero. Nell’esempio, worker può chiamare count_down() prima che il thread principale chiami wait(), quindi wait() da sola non garantisce che la lettura non atomica di result sia sicura con qualsiasi pianificazione dei thread. Il latch non protegge nemmeno da scritture concorrenti arbitrarie su dati condivisi.

L’oggetto deve rimanere in vita durante le operazioni che lo riguardano. Nell’esempio, worker viene distrutto prima di done, ma il thread principale non si affida al distruttore di std::jthread: chiama esplicitamente worker.join() dopo wait() e prima di leggere result. La conclusione del thread di lavoro si sincronizza con il ritorno senza errori da worker.join(), quindi la lettura di result è sicura a prescindere dal fatto che wait() si sia bloccata o meno. Se l’esecuzione va a buon fine, il programma stampa 42 seguito da un carattere di nuova riga.

Esempi

#include <iostream>
#include <latch>
#include <thread>

int main() {
    int result = 0;
    std::latch done{1};

    std::jthread worker([&] {
        result = 42;
        done.count_down();
    });

    done.wait();
    worker.join();
    std::cout << result << '\n';
}

Risultato

42

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti