Ver el código de «cpp/header/thread»

No tienes permiso para modificar esta página, por el siguiente motivo:
La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.
Puedes ver y copiar el código fuente de esta página.
{{cpp/header/title|thread}}
{{cpp/header/navbar}}
Este archivo de encabezado es parte de la biblioteca de [[cpp/thread|soporte de hilos/subprocesos]].
{{dsc begin}}
{{dsc h1|Clases}}
{{dsc inc | cpp/thread/dsc thread}}
{{dsc inc | cpp/thread/dsc jthread}}
{{dsc h1|Funciones}}
{{dsc inc | cpp/thread/thread/dsc swap2|thread}}
{{dsc inc | cpp/thread/thread/id/dsc operator_cmp}}
{{dsc inc | cpp/thread/thread/id/dsc operator_ltlt}}
{{dsc ptclass | cpp/thread/thread/id/hash | title=std::hash{{dsc small|<std::thread::id>}} | Especializa a {{lc|std::hash}}}}
{{dsc h1|Espacios de nombres}}
{{dsc | {{ttb|this_thread}} | Proporciona funciones que acceden al hilo de ejecución actual.}}
{{dsc h2|Funciones}}
{{dsc namespace | std::this_thread }}
{{dsc inc | cpp/thread/dsc yield}}
{{dsc inc | cpp/thread/dsc get_id}}
{{dsc inc | cpp/thread/dsc sleep_for}}
{{dsc inc | cpp/thread/dsc sleep_until}}
{{dsc end}}

===Sinopsis===

{{source|1=
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 {{lc|std::thread}}====
{{source|1=
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 {{lc|std::jthread}}====
{{source|1=
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 {{lc|std::thread::id}}====
{{source|1=
class thread::id {
 public:
    id() noexcept;
};
}}

{{langlinks|en|ja|zh}}
Plantillas usadas en esta página:
Volver a cpp/header/thread.
cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/header/thread»

Navegación

Herramientas
