thread.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_THREAD_HPP__
#define NEFORCE_CORE_ASYNC_THREAD_HPP__

 
#include "NeForce/core/async/this_thread.hpp"
#include "NeForce/core/exception/exception.hpp"
#include "NeForce/core/functional/apply.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#ifdef NEFORCE_PLATFORM_LINUX
#    include <pthread.h>
#endif
NEFORCE_BEGIN_NAMESPACE__


struct thread_exception final : system_exception {
    explicit thread_exception(const char* info = "Thread Operation Failed.", const char* type = static_type,
                              const int code = 0) noexcept :
    system_exception(info, type, code) {}
 
    explicit thread_exception(const exception& e) :
    system_exception(e) {}
 
    ~thread_exception() override = default;
 
    static constexpr auto static_type = "thread_exception";
};
 // Exceptions



class NEFORCE_API thread {
public:
    struct id : ihashable<id> {
    private:
        using native_id_type =
#ifdef NEFORCE_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) {}

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

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

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

        NEFORCE_NODISCARD bool operator!=(const id& rhs) const noexcept { return !(*this == rhs); }
    };

    struct NEFORCE_API hook {
        enum class point {
            before_create, 
            after_create,  
            thread_start,  
            thread_end,    
            before_destroy 
        };
 
        using callback_t = void (*)(point point, id thread_id); 

        static void add_hook(callback_t hook);

        static void remove_hook(callback_t hook);

        static void invoke(point point, id thread_id);
    };
 
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_(_NEFORCE forward<F>(f)) {}
 
        void run() override { func_(); }
    };

    struct thread_startup_args {
        unique_ptr<data_base> data; 
        id thread_id;               
    };

    struct NEFORCE_API thread_monitor {
    private:
        id thread_id_; 
 
    public:
        explicit thread_monitor(id thread_id);

        ~thread_monitor() noexcept;
    };
 
public:
    using native_handle_type =
#ifdef NEFORCE_PLATFORM_WINDOWS
            ::HANDLE;
#else
            ::pthread_t;
#endif
 
private:
    native_handle_type handle_{}; 
    id id_{0};                    
    state state_ = NOT_A_THREAD;  
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    static unsigned int __stdcall thread_entry(void* arg);
#else
    static void* thread_entry(void* arg);
#endif
 
    void start_thread_impl(thread_startup_args* args);
 
    template <typename F>
    void start_thread(F&& f) {
        auto data = _NEFORCE make_unique<thread_data<decay_t<F>>>(_NEFORCE forward<F>(f));
        this->start_thread_impl(new thread_startup_args{_NEFORCE move(data), id_});
    }
 
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 = _NEFORCE move(f), args = _NEFORCE make_tuple(_NEFORCE forward<Args>(args)...)]() mutable {
            return _NEFORCE apply(_NEFORCE move(func), _NEFORCE move(args));
        };
        thread::start_thread(_NEFORCE move(func));
    }
 
    thread(const thread&) = delete;
    thread& operator=(const thread&) = delete;

    thread(thread&& other) noexcept;

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

    ~thread();

    template <typename F, typename... Args>
    void start(F&& f, Args&&... args) {
        if (state_ != NOT_A_THREAD) {
            NEFORCE_THROW_EXCEPTION(thread_exception("Thread already started or has been joined/detached."));
        }
        auto func = [func = _NEFORCE forward<F>(f),
                     args = _NEFORCE make_tuple(_NEFORCE forward<Args>(args)...)]() mutable {
            return _NEFORCE apply(_NEFORCE move(func), _NEFORCE move(args));
        };
        this->start_thread(_NEFORCE move(func));
    }

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

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

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

    void join();

    void detach();

    bool set_name(const char* name);

    bool name(char* buffer, size_t size) const;

    void swap(thread& other) noexcept;

    static bool set_name(native_handle_type handle, const char* name);

    static bool name(native_handle_type handle, char* buffer, size_t size);
};
 // Thread
 // AsyncComponents
 
NEFORCE_BEGIN_THIS_THREAD__



NEFORCE_ALWAYS_INLINE_INLINE thread::id id() noexcept {
#ifdef NEFORCE_PLATFORM_WINDOWS
    return thread::id(::GetCurrentThreadId());
#else
    return thread::id(::pthread_self());
#endif
}

NEFORCE_ALWAYS_INLINE_INLINE thread::native_handle_type handle() noexcept {
#ifdef NEFORCE_PLATFORM_WINDOWS
    return ::GetCurrentThread();
#else
    return ::pthread_self();
#endif
}

NEFORCE_ALWAYS_INLINE_INLINE bool name(char* buffer, size_t size) {
    return thread::name(this_thread::handle(), buffer, size);
}

NEFORCE_ALWAYS_INLINE_INLINE bool set_name(const char* name) { return thread::set_name(this_thread::handle(), name); }
 // Thread
 // AsyncComponents
 
NEFORCE_END_THIS_THREAD__
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_THREAD_HPP__