Archivo de encabezado de la biblioteca estándar <thread>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnósticos <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <type_traits> (C++11) <ratio> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numéricos <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/Salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo para concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

See More

Este archivo de encabezado es parte de la biblioteca de soporte de hilos/subprocesos.

Clases
thread (C++11)	Gestiona un hilo/subproceso independiente. (clase)
jthread (C++20)	std::thread con soporte para unión y cancelación automática. (clase)
Funciones
std::swap(std::thread) (C++11)	Especializa el algoritmo std::swap. (función)
operator==operator!=operator< operator<= operator> operator>= operator<=> (eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(C++20)	Compara dos objetos thread::id. (función)
operator<<	Serializa un objeto identificador de hilo/subproceso (thread::id. (plantilla de función)
std::hash<std::thread::id>	Especializa a std::hash (especialización de plantilla de clase)
Espacios de nombres
this_thread	Proporciona funciones que acceden al hilo de ejecución actual.
Funciones
Definido en el espacio de nombres std::this_thread
yield (C++11)	Sugiere a la implementación que reprograme la ejecución de hilos. (función)
get_id (C++11)	Devuelve el identificador de hilo/subproceso del hilo/subproceso actual. (función)
sleep_for (C++11)	Detiene la ejecución del hilo/subproceso actual por una duración de tiempo especificada. (función)
sleep_until (C++11)	Detiene la ejecución del hilo/subproceso actual hasta que ocurra un punto de tiempo especificado. (función)

Sinopsis

namespace std {
    class thread;

    void swap(thread& x, thread& y) noexcept;

    // clase jthread
    class jthread;

    bool operator==(thread::id x, thread::id y) noexcept;
    bool operator!=(thread::id x, thread::id y) noexcept;

    bool operator<(thread::id x, thread::id y) noexcept;
    bool operator<=(thread::id x, thread::id y) noexcept;
    bool operator>(thread::id x, thread::id y) noexcept;
    bool operator>=(thread::id x, thread::id y) noexcept;

    template<class CharT, class Traits>
    basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& out,
                                            thread::id id);
    
    template <class T> struct hash;
    template <> struct hash<thread::id>;

    namespace this_thread {

        thread::id get_id() noexcept;
        void yield() noexcept;
        template <class Clock, class Duration>
            void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
        template <class Rep, class Period>
            void sleep_for(const chrono::duration<Rep, Period>& rel_time);

    }
}

Clase std::thread

class thread {
 public:
    // tipos:
    class id;
    typedef /*definido por la implementación*/ native_handle_type;

    // construcción/copia/destrucción:
    thread() noexcept;
    template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
    ~thread();
    thread(const thread&) = delete;
    thread(thread&&) noexcept;
    thread& operator=(const thread&) = delete;
    thread& operator=(thread&&) noexcept;

    // miembros:
    void swap(thread&) noexcept;
    bool joinable() const noexcept;
    void join();
    void detach();
    id get_id() const noexcept;
    native_handle_type native_handle();

    // miembros estáticos:
    static unsigned hardware_concurrency() noexcept;
};

Clase std::jthread

namespace std {
    class jthread {
    public:
        // tipos
        using id = thread::id;
        using native_handle_type = thread::native_handle_type;

        // constructores, movimientos y asignación
        jthread() noexcept;
        template<class F, class... Args> explicit jthread(F&& f, Args&&... args);
        ~jthread();
        jthread(const jthread&) = delete;
        jthread(jthread&&) noexcept;
        jthread& operator=(const jthread&) = delete;
        jthread& operator=(jthread&&) noexcept;

        // miembros
        void swap(jthread&) noexcept;
        [[nodiscard]] bool joinable() const noexcept;
        void join();
        void detach();
        [[nodiscard]] id get_id() const noexcept;
        [[nodiscard]] native_handle_type native_handle();

        // manejo de símbolo de detención
        [[nodiscard]] stop_source get_stop_source() noexcept;
        [[nodiscard]] stop_token get_stop_token() const noexcept;
        bool request_stop() noexcept;

        // algoritmos especializados
        friend void swap(jthread& lhs, jthread& rhs) noexcept;

        // miembros estáticos
        [[nodiscard]] static unsigned int hardware_concurrency() noexcept;

    private:
        stop_source ssource;        // solo exposición
    };
}

Clase std::thread::id

class thread::id {
 public:
    id() noexcept;
};