Class thread_pool

dlib/threads/thread_pool_extension.h:489–1362

// ----------------------------------------------------------------------------------------

    class thread_pool 
    {
        /*!
            This object is just a shell that holds a std::shared_ptr 
            to the real thread_pool_implementation object.  The reason for doing
            it this way is so that we can allow any mixture of destruction orders
            between thread_pool objects and futures.  Whoever gets destroyed
            last cleans up the thread_pool_implementation resources.
        !*/
        typedef bound_function_pointer::kernel_1a_c bfp_type;

    public:
        explicit thread_pool (
            unsigned long num_threads
        ) 
        {
            impl.reset(new thread_pool_implementation(num_threads));
        }

        ~thread_pool (
        )
        {
            try
            {
                impl->shutdown_pool();
            }
            catch (std::exception& e)
            {
                std::cerr << "An unhandled exception was inside a dlib::thread_pool when it was destructed." << std::endl;
                std::cerr << "It's what string is: \n" << e.what() << std::endl;
                assert(false);
                abort();
            }
            catch (...)
            {
                std::cerr << "An unhandled exception was inside a dlib::thread_pool when it was destructed." << std::endl;
                assert(false);
                abort();
            }
        }

        void wait_for_task (
            uint64 task_id
        ) const { impl->wait_for_task(task_id); }

        unsigned long num_threads_in_pool (
        ) const { return impl->num_threads_in_pool(); }

        void wait_for_all_tasks (
        ) const { impl->wait_for_all_tasks(); }

        bool is_task_thread (
        ) const { return impl->is_task_thread(); }

        template <typename T>
        uint64 add_task (
            T& obj,
            void (T::*funct)()