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 {
  namespace threading {
    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<class start_t>
      explicit thread(start_t start) : thread(parameterized_thread_start {start}) {}
      template<class 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;
      thread& operator=(const thread&);
      ~thread();
      
      
      bool auto_join() const noexcept;
      thread& auto_join(bool value);
 
      intptr handle() const noexcept;
 
      bool is_alive() const noexcept;
      
      bool is_background() const noexcept;
      thread& is_background(bool value);
 
      bool is_main_thread() const noexcept;
 
      bool is_thread_pool_thread() const noexcept;
      
      bool joinable() const noexcept;
 
      int32 managed_thread_id() const noexcept;
      
      string name() const noexcept;
      thread& name(const string& value);
 
      xtd::threading::thread_priority priority() const noexcept;
      thread& priority(xtd::threading::thread_priority value);
 
      intptr thread_id() const noexcept;
 
      xtd::threading::thread_state thread_state() const noexcept;
 
      
      static thread& current_thread() noexcept;
 
      static thread& main_thread();
 
      
      void abort();
      
      void detach();
 
      xtd::size get_hash_code() const noexcept override;
 
      void interrupt();
 
      void join();
      
      bool join(int32 milliseconds_timeout);
      
      bool join(const time_span& timeout);
 
      void resume();
      
      void start();
      
      void start(const xtd::any_object& obj);
 
      void suspend();
      
      
      static thread start_new(const xtd::threading::thread_start& start);
      static thread start_new(const xtd::threading::parameterized_thread_start& start, const xtd::any_object& obj);
 
      static void join_all();
      static bool join_all(int32 milliseconds_timeout);
      static bool join_all(const time_span& timeout);
      
      template<class collection_t>
      static void join_all(const collection_t& threads) {join_all(threads, timeout::infinite);}
      template<class collection_t>
      static bool join_all(const collection_t& threads, int32 milliseconds_timeout) {
        auto thread_pointers = xtd::array<thread*> {};
        for (auto& item : threads)
          thread_pointers.resize(thread_pointers.size() + 1, const_cast<thread*>(&item));
        return join_all_ptr(thread_pointers, milliseconds_timeout);
      }
      template<class collection_t>
      static bool join_all(const collection_t& threads, const time_span& timeout) {return join_all(threads, as<int32>(timeout.total_milliseconds_duration().count()));}
      
      static void sleep(int32 milliseconds_timeout);
      
      static void sleep(const time_span& timeout);
      
      static void spin_wait(int32 iterations);
 
      static bool yield() noexcept;
      
      template<class item_t>
      static bool join_all(const std::initializer_list<item_t>& threads) {return join_all(threads, timeout::infinite);}
      template<class item_t>
      static bool join_all(const std::initializer_list<item_t>& threads, int32 milliseconds_timeout) {
        auto thread_pointers = xtd::array<thread*> {};
        for (auto& item : threads)
          thread_pointers.resize(thread_pointers.size() + 1, const_cast<thread*>(&item));
        return join_all_ptr(thread_pointers, milliseconds_timeout);
      }
      template<class item_t>
      static bool join_all(const std::initializer_list<item_t>& threads, const time_span& timeout) {return join_all(threads, as<int32>(timeout.total_milliseconds_duration().count()));}
      static bool join_all(const std::initializer_list<xtd::sptr<thread>>& threads);
      static bool join_all(const std::initializer_list<xtd::sptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const std::initializer_list<xtd::sptr<thread>>& threads, const time_span& timeout);
      static bool join_all(const std::initializer_list<xtd::uptr<thread>>& threads);
      static bool join_all(const std::initializer_list<xtd::uptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const std::initializer_list<xtd::uptr<thread>>& threads, const time_span& timeout);
      static bool join_all(const xtd::array<xtd::sptr<thread>>& threads);
      static bool join_all(const xtd::array<xtd::sptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const xtd::array<xtd::sptr<thread>>& threads, const time_span& timeout);
      static bool join_all(const std::vector<xtd::uptr<thread>>& threads);
      static bool join_all(const std::vector<xtd::uptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const std::vector<xtd::uptr<thread>>& threads, const time_span& timeout);
      template<class start_t>
      static thread start_new(start_t start) {return start_new(thread_start {start});}
      template<class start_t>
      static thread start_new(start_t start, const xtd::any_object& obj) {return start_new(parameterized_thread_start {start}, obj);}
      
    private:
      friend class thread_pool;
      friend class wait_handle;
 
      void close();
      static bool do_wait(wait_handle& wait_handle, int32 milliseconds_timeout);
      static int32 generate_managed_thread_id() noexcept;
      static intptr get_current_thread_handle();
      static intptr get_current_thread_id() noexcept;
      static static_data& get_static_data();
      static thread& get_thread(intptr thread_id);
      void interrupt_internal();
      bool is_aborted() const noexcept;
      bool is_stopped() const noexcept;
      bool is_suspended() const noexcept;
      void is_thread_pool_thread(bool value) noexcept;
      bool is_unmanaged_thread() const noexcept;
      bool is_unstarted() const noexcept;
      bool is_wait_sleep_join() const noexcept;
      static bool join_all_ptr(const xtd::array<thread*>& threads, int32 milliseconds_timeout);
      void thread_proc();
      static thread& unmanaged_thread();
 
      static constexpr int32 main_managed_thread_id = 1;
      static constexpr int32 unmanaged_thread_id = 0;
 
      xtd::sptr<data> data_;
      static intptr main_thread_id_;
    };
    
    namespace this_thread {
      
      xtd::intptr handle() noexcept;
      
      xtd::int32 managed_thread_id() noexcept;
      
      xtd::string name() noexcept;
      void name(const xtd::string& name);
      
      xtd::threading::thread_priority priority() noexcept;
      void priority(xtd::threading::thread_priority priority);
      
      xtd::intptr thread_id() noexcept;
      
      
      xtd::intptr get_id() noexcept;
      
      void sleep_for(const xtd::time_span& sleep_duration);
      
      void sleep_until(const xtd::date_time& sleep_time);
      
      bool yield() noexcept;
    }
  }
}