thread_pool.hpp

Go to the documentation of this file.

#pragma once
#include "registered_wait_handle.hpp"
#include "semaphore.hpp"
#include "thread.hpp"
#include "wait_callback.hpp"
#include "wait_or_timer_callback.hpp"
#include "../core_export.hpp"
#include "../new_ptr.hpp"
#include "../static.hpp"
#include "../time_span.hpp"
#include "../types.hpp"

namespace xtd {
  namespace threading {
    class core_export_ thread_pool static_ {
      friend class registered_wait_handle;
      
      struct static_data;
      
      template<class callback_t>
      class thread_item : public object {
        struct sdata {
          sdata() = default;
          sdata(sdata&&) = default;
          sdata(const sdata&) = default;
          sdata& operator =(sdata&&) = default;
          sdata& operator =(const sdata&) = default;
          sdata(const callback_t& callback) : callback {callback} {}
          sdata(const callback_t& callback, const xtd::any_object& state) : callback {callback}, state {state} {}
          sdata(const callback_t& callback, const xtd::any_object& state, wait_handle* wait_object, int32 milliseconds_timeout_interval, bool execute_only_once) : callback {callback}, state {state}, wait_object {wait_object}, milliseconds_timeout_interval {milliseconds_timeout_interval}, execute_only_once {execute_only_once} {}
          
          callback_t callback;
          xtd::any_object state;
          wait_handle* wait_object = null;
          int32 milliseconds_timeout_interval;
          bool execute_only_once = true;
          bool unregistered = false;
        };
        
      public:
        thread_item() = default;
        thread_item(thread_item&&) = default;
        thread_item(const thread_item& other) {*data = *other.data;}
        thread_item& operator =(thread_item&&) = default;
        thread_item& operator =(const thread_item& other) {*data = *other.data; return *this;}
        thread_item(const callback_t& callback) : data {xtd::new_ptr<sdata>(callback)} {}
        thread_item(const callback_t& callback, const xtd::any_object& state) : data {xtd::new_ptr<sdata>(callback, state)} {}
        thread_item(const callback_t& callback, const xtd::any_object& state, wait_handle& wait_object, int32 milliseconds_timeout_interval, bool execute_only_once) : data {xtd::new_ptr<sdata>(callback, state, &wait_object, milliseconds_timeout_interval, execute_only_once)} {}
        
        [[nodiscard]] auto execute_only_once() const noexcept -> bool {return data->execute_only_once;}
        [[nodiscard]] auto milliseconds_timeout_interval() const noexcept -> int32 {return data->milliseconds_timeout_interval;}
        [[nodiscard]] auto unregistered() const noexcept -> bool {return data->unregistered;}
        auto unregistered(bool value) noexcept -> void {data->unregistered = value;}
        auto wait_object() noexcept -> wait_handle* {return data->wait_object;}
        
        auto run() -> void {data->callback(data->state);}
        auto run(bool timeout) -> void {data->callback(data->state, timeout);}
        
      private:
        ptr<sdata> data = xtd::new_ptr<sdata>();
      };
      
      using thread_pool_item = thread_item<wait_callback>;
      using thread_pool_asynchronous_io_item = thread_item<wait_or_timer_callback>;
      using thread_pool_item_collection = xtd::collections::generic::list<thread_pool_item>;
      using thread_pool_asynchronous_io_item_collection = xtd::collections::generic::list<thread_pool_asynchronous_io_item>;
      
    public:
      
      static auto close() -> void;
      
      static auto get_available_threads(size_t& worker_threads, size_t& completion_port_threads) -> void;
      
      static auto get_max_threads(size_t& worker_threads, size_t& completion_port_threads) -> void;
      
      static auto get_min_threads(size_t& worker_threads, size_t& completion_port_threads) -> void;
      
      static auto join_all() -> void;
      static auto join_all(int32 milliseconds_timeout) -> bool;
      static auto join_all(const time_span& timeout) -> bool;
      
      static auto queue_user_work_item(const wait_callback& callback) -> void;
      static auto queue_user_work_item(const wait_callback& callback, const xtd::any_object& state) -> void;
      
      template<class callback_t>
      static auto queue_user_work_item(callback_t callback) -> void {queue_user_work_item(wait_callback {callback});}
      template<class callback_t>
      static auto queue_user_work_item(callback_t callback, const xtd::any_object& state) -> void {queue_user_work_item(wait_callback {callback}, state);}
      
      static auto register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, const xtd::any_object& state, int32 milliseconds_timeout_interval, bool execute_only_once) -> registered_wait_handle;
      static auto register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, const xtd::any_object& state, int64 milliseconds_timeout_interval, bool execute_only_once) -> registered_wait_handle;
      static auto register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, const xtd::any_object& state, const time_span& timeout, bool execute_only_once) -> registered_wait_handle;
      static auto register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, const xtd::any_object& state, uint32 milliseconds_timeout_interval, bool execute_only_once) -> registered_wait_handle;
      
      template<class callback_t>
      static auto register_wait_for_single_object(wait_handle& wait_object, callback_t callback, const xtd::any_object& state, int32 milliseconds_timeout_interval, bool execute_only_once) -> registered_wait_handle {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, milliseconds_timeout_interval, execute_only_once);}
      template<class callback_t>
      static auto register_wait_for_single_object(wait_handle& wait_object, callback_t callback, const xtd::any_object& state, int64 milliseconds_timeout_interval, bool execute_only_once) -> registered_wait_handle {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, milliseconds_timeout_interval, execute_only_once);}
      template<class callback_t>
      static auto register_wait_for_single_object(wait_handle& wait_object, callback_t callback, const xtd::any_object& state, const time_span& timeout, bool execute_only_once) -> registered_wait_handle {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, timeout, execute_only_once);}
      template<class callback_t>
      static auto register_wait_for_single_object(wait_handle& wait_object, callback_t callback, const xtd::any_object& state, uint32 milliseconds_timeout_interval, bool execute_only_once) -> registered_wait_handle {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, milliseconds_timeout_interval, execute_only_once);}
      
      static auto set_max_threads(size_t worker_threads, size_t completion_port_threads) -> bool;
      
      static auto set_min_threads(size_t worker_threads, size_t completion_port_threads) -> bool;
      
    private:
      friend class xtd::threading::thread;
      static auto asynchronous_io_run() -> void;
      static auto create_thread() -> void;
      static auto create_asynchronous_io_thread() -> void;
      static auto initialize_min_threads() -> void;
      static auto initialize_min_asynchronous_io_threads() -> void;
      static auto join_all_threads(int32 milliseconds_timeout) -> bool;
      static auto join_all_asynchronous_io_threads(int32 milliseconds_timeout) -> bool;
      static auto run() -> void;
      
      static size_t max_threads_;
      static size_t max_asynchronous_io_threads_;
      static size_t min_threads_;
      static size_t min_asynchronous_io_threads_;
      static static_data static_data_;
    };
  }
}

// Add xtd::delegate::begin_invoke and xtd::delegate::end_invoke methods.
#define __XTD_CORE_INTERNAL__
#include "../internal/__delegate.hpp"
#undef __XTD_CORE_INTERNAL__