thread.hpp

Go to the documentation of this file.

#pragma once
#include "parameterized_thread_start.hpp"
#include "wait_handle.hpp"
#include "thread_priority.hpp"
#include "thread_start.hpp"
#include "thread_state.hpp"
#include "../as.hpp"
#include "../core_export.hpp"
//#include "../date_time.hpp"
#include "../intptr.hpp"
#include "../object.hpp"
#include "../time_span.hpp"
#include "../types.hpp"

namespace xtd {
  class date_time;
  
  namespace threading {
    namespace tasks {
      template<typename result_t = void>
      class basic_task;
    }
    class thread_pool;
    
    class core_export_ thread : public object {
      struct data;
      
      struct static_data;
      
    public:
      
      static const intptr invalid_handle;
      
      static const intptr invalid_thread_id;
      
      
      explicit thread(const xtd::threading::parameterized_thread_start& start);
      thread(const xtd::threading::parameterized_thread_start& start, int32 max_stack_size);
      explicit thread(const xtd::threading::thread_start& start);
      thread(const xtd::threading::thread_start& start, int32 max_stack_size);
      
      thread();
      template<typename start_t>
      explicit thread(start_t start) : thread(parameterized_thread_start {start}) {}
      template<typename start_t>
      thread(start_t start, int32 max_stack_size) : thread(parameterized_thread_start {start}, max_stack_size) {}
      thread(thread&&) = default;
      thread(const thread&) = default;
      auto operator=(thread&&) -> thread& = default;
      auto operator=(const thread&) -> thread&;
      ~thread();
      
      
      [[nodiscard]] auto auto_join() const noexcept -> bool;
      auto auto_join(bool value) -> thread&;
      
      [[nodiscard]] auto handle() const noexcept -> intptr;
      
      [[nodiscard]] auto is_alive() const noexcept -> bool;
      
      [[nodiscard]] auto is_background() const noexcept -> bool;
      auto is_background(bool value) -> thread&;
      
      [[nodiscard]] auto is_main_thread() const noexcept -> bool;
      
      [[nodiscard]] auto is_thread_pool_thread() const noexcept -> bool;
      
      [[nodiscard]] auto joinable() const noexcept -> bool;
      
      [[nodiscard]] auto managed_thread_id() const noexcept -> int32;
      
      [[nodiscard]] auto name() const noexcept -> string;
      auto name(const string& value) -> thread&;
      
      [[nodiscard]] auto priority() const noexcept -> xtd::threading::thread_priority;
      auto priority(xtd::threading::thread_priority value) -> thread&;
      
      [[nodiscard]] auto processor_affinity() const noexcept -> const xtd::array<xtd::usize>&;
      auto processor_affinity(const xtd::array<xtd::usize>& value) -> thread&;
      
      [[nodiscard]] auto thread_id() const noexcept -> intptr;
      
      [[nodiscard]] auto thread_state() const noexcept -> xtd::threading::thread_state;
      
      
      [[nodiscard]] static auto current_thread() noexcept -> thread&;
      
      
      auto abort() -> void;
      
      auto detach() -> void;
      
      [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override;
      
      auto interrupt() -> void;
      
      auto join() -> void;
      
      auto join(int32 milliseconds_timeout) -> bool;
      
      auto join(const time_span& timeout) -> bool;
      
      auto resume() -> void;
      
      auto start() -> void;
      
      auto start(const xtd::any_object& obj) -> void;
      
      auto suspend() -> void;
      
      
      static auto start_new(const xtd::threading::thread_start& start) -> thread;
      static auto start_new(const xtd::threading::parameterized_thread_start& start, const xtd::any_object& obj) -> thread;
      
      static auto join_all() -> void;
      static auto join_all(int32 milliseconds_timeout) -> bool;
      static auto join_all(const time_span& timeout) -> bool;
      
      template<typename collection_t>
      static auto join_all(const collection_t& threads) -> void {join_all(threads, timeout::infinite);}
      template<typename collection_t>
      static auto join_all(const collection_t& threads, int32 milliseconds_timeout) -> bool {
        auto thread_pointers = xtd::array<thread*> {};
        for (auto& item : threads) {
          if (item.thread_id() == get_current_thread_id()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
          thread_pointers.resize(thread_pointers.length() + 1, const_cast<thread*>(&item));
        }
        return join_all_ptr(thread_pointers, milliseconds_timeout);
      }

      template<typename collection_t>
      static auto join_all(const collection_t& threads, const time_span& timeout) -> bool {return join_all(threads, as<int32>(timeout.total_milliseconds_duration().count()));}
      
      static auto sleep(int32 milliseconds_timeout) -> void;
      
      static auto sleep(const time_span& timeout) -> void;
      
      static auto spin_wait(int32 iterations) -> void;
      
      static auto yield() noexcept -> bool;
      
      template<typename item_t>
      static auto join_all(const std::initializer_list<item_t>& threads) -> bool {return join_all(threads, timeout::infinite);}
      template<typename item_t>
      static auto join_all(const std::initializer_list<item_t>& threads, int32 milliseconds_timeout) -> bool {
        auto thread_pointers = xtd::array<thread*> {};
        for (auto& item : threads) {
          if (item.thread_id() == get_current_thread_id()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
          thread_pointers.resize(thread_pointers.length() + 1, const_cast<thread*>(&item));
        }
        return join_all_ptr(thread_pointers, milliseconds_timeout);
      }
      template<typename item_t>
      static auto join_all(const std::initializer_list<item_t>& threads, const time_span& timeout) -> bool {return join_all(threads, as<int32>(timeout.total_milliseconds_duration().count()));}
      static auto join_all(const std::initializer_list<xtd::sptr<thread>>& threads) -> bool;
      static auto join_all(const std::initializer_list<xtd::sptr<thread>>& threads, int32 milliseconds_timeout) -> bool;
      static auto join_all(const std::initializer_list<xtd::sptr<thread>>& threads, const time_span& timeout) -> bool;
      static auto join_all(const std::initializer_list<xtd::uptr<thread>>& threads) -> bool;
      static auto join_all(const std::initializer_list<xtd::uptr<thread>>& threads, int32 milliseconds_timeout) -> bool;
      static auto join_all(const std::initializer_list<xtd::uptr<thread>>& threads, const time_span& timeout) -> bool;
      static auto join_all(const xtd::array<xtd::sptr<thread>>& threads) -> bool;
      static auto join_all(const xtd::array<xtd::sptr<thread>>& threads, int32 milliseconds_timeout) -> bool;
      static auto join_all(const xtd::array<xtd::sptr<thread>>& threads, const time_span& timeout) -> bool;
      static auto join_all(const xtd::array<xtd::uptr<thread>>& threads) -> bool;
      static auto join_all(const xtd::array<xtd::uptr<thread>>& threads, int32 milliseconds_timeout) -> bool;
      static auto join_all(const xtd::array<xtd::uptr<thread>>& threads, const time_span& timeout) -> bool;
      template<typename start_t>
      static auto start_new(start_t start) -> thread {return start_new(thread_start {start});}
      template<typename start_t>
      static auto start_new(start_t start, const xtd::any_object& obj) -> thread {return start_new(parameterized_thread_start {start}, obj);}
      
    private:
      friend class thread_pool;
      friend class wait_handle;
      template<typename result_t>
      friend class tasks::basic_task;
      
      void close();
      static auto do_wait(wait_handle& wait_handle, int32 milliseconds_timeout) -> bool;
      [[nodiscard]] static auto generate_managed_thread_id() noexcept -> int32;
      [[nodiscard]] static auto get_current_thread_handle() -> intptr;
      [[nodiscard]] static auto get_current_thread_id() noexcept -> intptr;
      [[nodiscard]] static auto get_static_data() -> static_data&;
      [[nodiscard]] static auto get_thread(intptr thread_id) -> thread&;
      [[nodiscard]] auto get_managed_thread_id() noexcept -> int32&;
      auto interrupt_internal() -> void;
      [[nodiscard]] auto is_aborted() const noexcept -> bool;
      [[nodiscard]] auto is_stopped() const noexcept -> bool;
      [[nodiscard]] auto is_suspended() const noexcept -> bool;
      auto is_thread_pool_thread(bool value) noexcept -> void;
      [[nodiscard]] auto is_unmanaged_thread() const noexcept -> bool;
      [[nodiscard]] auto is_unstarted() const noexcept -> bool;
      [[nodiscard]] auto is_wait_sleep_join() const noexcept -> bool;
      static auto join_all_ptr(const xtd::array<thread*>& threads, int32 milliseconds_timeout) -> bool;
      [[nodiscard]] static auto main_thread() -> thread&;
      static auto set_main_managed_thread_id(int32 id) -> void {main_managed_thread_id = id;}
      auto thread_proc() -> void;
      [[nodiscard]] static auto unmanaged_thread() -> thread&;
      
      inline static int32 main_managed_thread_id = 1;
      static constexpr int32 unmanaged_thread_id = 0;
      
      xtd::sptr<data> data_;
      static intptr main_thread_id_;
    };
  }
}
 
#include "this_thread.hpp"