thread.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_ASYNC_THREAD_HPP__
#define MSTL_CORE_ASYNC_THREAD_HPP__

 
#include "MSTL/core/functional/apply.hpp"
#include "MSTL/core/exception/exception.hpp"
#include "MSTL/core/memory/unique_ptr.hpp"
#include "MSTL/core/async/this_thread.hpp"
#ifdef MSTL_PLATFORM_LINUX__
#include <pthread.h>
#endif
MSTL_BEGIN_NAMESPACE__


class MSTL_API thread {
public:
    struct id : ihashable<id> {
    private:
        using native_id_type =
#ifdef MSTL_PLATFORM_WINDOWS__
            ::DWORD;
#else
            ::pthread_t;
#endif
 
        native_id_type id_{};  
 
        friend class thread;
 
    public:
        id() noexcept = default;

        explicit id(const native_id_type id) noexcept : id_(id) {}

        MSTL_NODISCARD native_id_type native_handle() const noexcept { return id_; }

        MSTL_NODISCARD size_t to_hash() const noexcept {
            return _MSTL FNV_hash(reinterpret_cast<const byte_t*>(&id_), sizeof(id));
        }

        MSTL_NODISCARD bool operator ==(const id& rhs) const noexcept {
#ifdef MSTL_PLATFORM_WINDOWS__
            return id_ == rhs.id_;
#else
            return ::pthread_equal(id_, rhs.id_) != 0;
#endif
        }

        MSTL_NODISCARD bool operator !=(const id& rhs) const noexcept {
            return !(*this == rhs);
        }
    };
 
private:
    enum state {
        NOT_A_THREAD, 
        CREATED,      
        JOINED,       
        DETACHED      
    };

    struct data_base {
        virtual ~data_base() = default;
        virtual void run() = 0;
    };

    template <typename Callable>
    struct thread_data final : data_base {
        Callable func_;  

        template <typename F>
        explicit thread_data(F&& f) : func_(_MSTL forward<F>(f)) {}

        void run() override { func_(); }
    };
 
public:
    using native_handle_type =
#ifdef MSTL_PLATFORM_WINDOWS__
        ::HANDLE;
#else
        ::pthread_t;
#endif
 
private:
    native_handle_type handle_{}; 
    id id_{};                     
    state state_ = NOT_A_THREAD;  
 
#ifdef MSTL_PLATFORM_WINDOWS__
    static unsigned int __stdcall
#else
    static void*
#endif
    thread_entry(void* arg);

    void start_thread_impl(void* args);

    template <typename F>
    void start_thread(F&& f) {
        auto data = _MSTL make_unique<thread_data<decay_t<F>>>(_MSTL forward<F>(f));
        this->start_thread_impl(data.get());
        data.release();
        state_ = CREATED;
    }
 
public:
    thread() noexcept = default;

    template <typename F, typename... Args, typename = enable_if_t<!is_same_v<decay_t<F>, thread>>>
    explicit thread(F&& f, Args&&... args) {
        auto func = [func = _MSTL move(f), args = _MSTL make_tuple(_MSTL forward<Args>(args)...)]() mutable {
            return _MSTL apply(_MSTL move(func), _MSTL move(args));
        };
        thread::start_thread(_MSTL move(func));
    }

    thread(const thread&) = delete;

    thread& operator =(const thread&) = delete;

    thread(thread&& other) noexcept;

    thread& operator =(thread&& other) noexcept;

    ~thread();

    MSTL_NODISCARD id get_id() const noexcept { return id_; }

    MSTL_NODISCARD native_handle_type native_handle() const noexcept { return handle_; }

    MSTL_NODISCARD bool joinable() const noexcept { return state_ == CREATED; }

    void join();

    void detach();

    void swap(thread& other) noexcept {
        _MSTL swap(handle_, other.handle_);
        _MSTL swap(id_, other.id_);
        _MSTL swap(state_, other.state_);
    }
};
 // Thread
 
MSTL_BEGIN_THIS_THREAD__


MSTL_ALWAYS_INLINE_INLINE thread::id id() noexcept {
#ifdef MSTL_PLATFORM_WINDOWS__
    return thread::id(::GetCurrentThreadId());
#else
    return thread::id(::pthread_self());
#endif
}
 // Thread
 
MSTL_END_THIS_THREAD__
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_ASYNC_THREAD_HPP__