thread_pool.h

Go to the documentation of this file.

 
#pragma once
#include "registered_wait_handle.h"
#include "semaphore.h"
#include "thread.h"
#include "wait_callback.h"
#include "wait_or_timer_callback.h"
#include "../core_export.h"
#include "../new_ptr.h"
#include "../static.h"
#include "../time_span.h"
#include "../types.h"
#include <vector>
 
namespace xtd {
  namespace threading {
    class core_export_ thread_pool static_ {
      friend class registered_wait_handle;
 
      using asynchronous_io_thread_vector = std::vector<thread>;
 
      struct static_data;
 
      template<typename callback_t>
      struct thread_item : public object {
        thread_item() = default;
        thread_item(thread_item&&) = default;
        thread_item(const thread_item&) = default;
        thread_item& operator =(thread_item&&) = default;
        thread_item& operator =(const thread_item&) = default;
        thread_item(const callback_t& callback) : data {xtd::new_ptr<sdata>(callback)} {}
        thread_item(const callback_t& callback, std::any state) : data {xtd::new_ptr<sdata>(callback, state)} {}
        thread_item(const callback_t& callback, std::any 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)} {}
        
        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, std::any state) : callback {callback}, state {state} {}
          sdata(const callback_t& callback, std::any 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;
          std::any state;
          wait_handle* wait_object = null;
          int32 milliseconds_timeout_interval;
          bool execute_only_once = true;
          bool unregistered = false;
        };
        
        ptr<sdata> data = xtd::new_ptr<sdata>();
        
        void run() {
          do {
            this->callback(data->state);
          } while (!data->execute_only_once);
        }
      };
      
      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 = std::vector<thread_pool_item>;
      using thread_pool_asynchronous_io_item_collection = std::vector<thread_pool_asynchronous_io_item>;
 
      using thread_vector = std::vector<thread>;
 
    public:
 
      static void close();
 
      static void get_available_threads(size_t& worker_threads, size_t& completion_port_threads);
 
      static void get_max_threads(size_t& worker_threads, size_t& completion_port_threads);
      
      static void get_min_threads(size_t& worker_threads, size_t& completion_port_threads);
 
      static void join_all();
      static bool join_all(int32 milliseconds_timeout);
      static bool join_all(const time_span& timeout);
 
      static bool queue_user_work_item(const wait_callback& callback);
      static bool queue_user_work_item(const wait_callback& callback, std::any state);
 
      template <typename callback_t>
      static bool queue_user_work_item(callback_t callback) {return queue_user_work_item(wait_callback {callback});}
      template <typename callback_t>
      static bool queue_user_work_item(callback_t callback, std::any state) {return queue_user_work_item(wait_callback {callback}, state);}
 
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, std::any state, int32 milliseconds_timeout_interval, bool execute_only_once);
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, std::any state, int64 milliseconds_timeout_interval, bool execute_only_once);
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, std::any state, const time_span& timeout, bool execute_only_once);
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, const wait_or_timer_callback& callback, std::any state, uint32 milliseconds_timeout_interval, bool execute_only_once);
 
      template <typename callback_t>
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, callback_t callback, std::any state, int32 milliseconds_timeout_interval, bool execute_only_once) {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, milliseconds_timeout_interval, execute_only_once);}
      template <typename callback_t>
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, callback_t callback, std::any state, int64 milliseconds_timeout_interval, bool execute_only_once) {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, milliseconds_timeout_interval, execute_only_once);}
      template <typename callback_t>
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, callback_t callback, std::any state, const time_span& timeout, bool execute_only_once) {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, timeout, execute_only_once);}
      template <typename callback_t>
      static registered_wait_handle register_wait_for_single_object(wait_handle& wait_object, callback_t callback, std::any state, uint32 milliseconds_timeout_interval, bool execute_only_once) {return register_wait_for_single_object(wait_object, wait_or_timer_callback {callback}, state, milliseconds_timeout_interval, execute_only_once);}
      
      static bool set_max_threads(size_t worker_threads, size_t completion_port_threads);
      
      static bool set_min_threads(size_t worker_threads, size_t completion_port_threads);
 
    private:
      friend class xtd::threading::thread;
      static void asynchronous_io_run();
      static void create_thread();
      static void create_asynchronous_io_thread();
      static void initialize_min_threads();
      static void initialize_min_asynchronous_io_threads();
      static bool join_all_threads(int32 milliseconds_timeout);
      static bool join_all_asynchronous_io_threads(int32 milliseconds_timeout);
      static void run();
 
      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.h"
#undef __XTD_CORE_INTERNAL__