SubmitPoolTask()

template<typename ... Params>

template<typename Func , typename ... Args>

auto Spices::ThreadPool_Basic< Params >::SubmitPoolTask ( Func && func, Args &&... args ) -> std::future<decltype(func(std::forward<Args>(args)...))>

inlineinherited

Submit a task to task queue, and wait for a idle thread to execute it.

Template Parameters

Func	Task Function.
Args	Task Function Parameter.

Returns

Returns task function return value as a future.

pack function pointer with packaged_task and get future.

pack task as a lambda and submit it to queue.

Expand threads container if in MODE_CACHED.

Definition at line 703 of file ThreadPoolBasic.h.

    {
        SPICES_PROFILE_ZONE;
 
        using RType = decltype(func(args...));
 
        auto task = std::make_shared<std::packaged_task<RType()>>(std::bind(std::forward<Func>(func), std::forward<Args>(args)...));
        std::future<RType> result = task->get_future();
 
        {
            std::unique_lock<std::mutex> lock(m_Mutex);
 
            m_TaskQueue.emplace([task]() {(*task)(); });
            ++m_Tasks;
 
            if (m_PoolMode == PoolMode::MODE_CACHED && m_TaskQueue.size() > m_IdleThreadSize && m_Threads.size() < THREAD_MAX_THRESHHOLD)
            {
                for (uint32_t i = 0; i < THREAD_MAX_THRESHHOLD; i++)
                {
                    if (m_Threads.find(i) == m_Threads.end())
                    {
                        auto ptr = std::make_unique<Thread<>>(std::bind(&ThreadPool_Basic::ThreadFunc, this, std::placeholders::_1), i);
                        uint32_t threadId = ptr->GetId();
 
                        ptr->Start();
                        m_Threads.emplace(threadId, std::move(ptr));
 
                        ++m_IdleThreadSize;
                        ++m_NThreads;
 
                        break;
                    }
                }
            }
        }
 
        m_NotEmpty.notify_all();
 
        return result;
    }

References Spices::ThreadPool_Basic< Params >::m_NotEmpty, and Spices::THREAD_MAX_THRESHHOLD.