Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::thread — avviare un thread e gestirne il ciclo di vita

std::thread esegue una funzione invocabile in un thread separato. Scopri le differenze tra joinable(), join() e detach() e perché occorre risolvere l’associazione con il thread prima di distruggere l’oggetto corrispondente.

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

Sintassi

#include <thread>
std::thread t(callable);
bool active = t.joinable();
t.join();
// Alternative to join(): t.detach();

std::thread, definito in <thread>, rappresenta un thread di esecuzione; il costruttore che riceve una funzione invocabile la esegue in un nuovo thread. L’oggetto è spostabile, ma non copiabile. La costruzione predefinita non avvia alcun thread. Questa voce tratta l’API usata in C++23; la fonte fornita è una bozza di lavoro in evoluzione, non una pubblicazione definitiva di C++23.

std::thread::joinable() verifica se l’oggetto rappresenta ancora un thread, non se quel thread è ancora in esecuzione. Un thread terminato resta joinable finché join() o detach() non vengono completati correttamente. std::thread::join() attende la fine e sincronizza il completamento con il proprio ritorno corretto. Di conseguenza, l’esempio può leggere result dopo join() senza un mutex aggiuntivo.

std::thread::detach() rimuove l’associazione dell’oggetto con il thread senza attendere che il lavoro termini. Non arresta il thread né prolunga la durata degli oggetti acquisiti: i riferimenti a variabili locali possono diventare pendenti. Dopo un join() o detach() riuscito, joinable() restituisce false.

La distruzione di un oggetto joinable chiama std::terminate(), anche se il lavoro è già terminato. Gestisci la durata degli oggetti anche nei percorsi di eccezione; un’eccezione che esce dalla funzione del thread chiama anch’essa std::terminate(). join() e detach() possono generare std::system_error; non chiamarli su un oggetto non joinable e non chiamare join() dal thread rappresentato. Le operazioni sullo stesso oggetto std::thread non sono sincronizzate automaticamente.

Esempi

#include <iostream>
#include <thread>

int main() {
    int result = 0;
    std::thread worker([&result] { result = 42; });
    const bool before = worker.joinable();
    worker.join();
    std::cout << std::boolalpha
              << before << '\n'
              << worker.joinable() << '\n'
              << result << '\n';
}

Risultato

true
false
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