thread.h

Go to the documentation of this file.

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

namespace xtd {
  namespace threading {
    class thread_pool;
    
    class core_export_ thread final : public object {
      struct data;

      struct static_data;

      using thread_collection = std::vector<std::shared_ptr<thread>>;

    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>
      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;
      thread& operator=(const thread&);
      ~thread();
      
      
      static thread& current_thread();
      
      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;
      
      static thread& main_thread();

      int32 managed_thread_id() const noexcept;
      
      ustring name() const noexcept;
      thread& name(const ustring& 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;

      
      void abort();
      
      void detach();
      
      void interrupt();

      void join();
      
      bool join(int32 milliseconds_timeout);
      
      bool join(const time_span& timeout);

      static void join_all();
      static bool join_all(int32 milliseconds_timeout);
      static bool join_all(const time_span& timeout);

      template<typename collection_t>
      static void join_all(const collection_t& threads) {join_all(threads, timeout::infinite);}
      template<typename collection_t>
      static bool join_all(const collection_t& threads, int32 milliseconds_timeout) {
        std::vector<thread*> thread_pointers;
        for (auto& item : threads)
          thread_pointers.push_back(const_cast<thread*>(&item));
        return join_all_ptr(thread_pointers, milliseconds_timeout);
      }
      template<typename 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()));}

      void resume();

      static void sleep(int32 milliseconds_timeout);
      
      static void sleep(const time_span& timeout);

      static void spin_wait(int32 iterations);
      
      void start();
      
      void start(std::any obj);
      
      static thread start_new(const xtd::threading::thread_start& start);
      static thread start_new(const xtd::threading::parameterized_thread_start& start, std::any obj);

      void suspend();

      static bool yield();
      
      template<typename item_t>
      static bool join_all(const std::initializer_list<item_t>& threads) {return join_all(threads, timeout::infinite);}
      template<typename item_t>
      static bool join_all(const std::initializer_list<item_t>& threads, int32 milliseconds_timeout) {
        std::vector<thread*> thread_pointers;
        for (auto& item : threads)
          thread_pointers.push_back(const_cast<thread*>(&item));
        return join_all_ptr(thread_pointers, milliseconds_timeout);
      }
      template<typename 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<std::shared_ptr<thread>>& threads);
      static bool join_all(const std::initializer_list<std::shared_ptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const std::initializer_list<std::shared_ptr<thread>>& threads, const time_span& timeout);
      static bool join_all(const std::initializer_list<std::unique_ptr<thread>>& threads);
      static bool join_all(const std::initializer_list<std::unique_ptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const std::initializer_list<std::unique_ptr<thread>>& threads, const time_span& timeout);
      static bool join_all(const std::vector<std::shared_ptr<thread>>& threads);
      static bool join_all(const std::vector<std::shared_ptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const std::vector<std::shared_ptr<thread>>& threads, const time_span& timeout);
      static bool join_all(const std::vector<std::unique_ptr<thread>>& threads);
      static bool join_all(const std::vector<std::unique_ptr<thread>>& threads, int32 milliseconds_timeout);
      static bool join_all(const std::vector<std::unique_ptr<thread>>& threads, const time_span& timeout);
      template <typename start_t>
      static thread start_new(start_t start) {return start_new(thread_start {start});}
      template <typename start_t>
      static thread start_new(start_t start, std::any 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();
      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 std::vector<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;

      std::shared_ptr<data> data_;
      static intptr main_thread_id_;
    };
  }
}