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 "../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(const callback_t& callback) : callback(callback) {}
        thread_item(const callback_t& callback, std::any state) : callback(callback), state(state) {}
        thread_item(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;
        
        void run() {
          do {
            this->callback(state);
          } while (!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__