Class FutureThreadPool

src/core/include/megbrain/utils/async_worker_impl_1.h:100–207

 */
template <class R>
class FutureThreadPool final : public NonCopyableObj {
    using Task = std::packaged_task<R()>;
    std::deque<Task> m_tasks;
    std::mutex m_mtx;
    std::condition_variable m_cv_more_task;

    std::vector<std::thread> m_worker_threads;
    std::vector<std::thread::id> m_worker_tids;
    Maybe<std::string> m_name;
    bool m_should_stop = true;

    void worker_impl(size_t id) {
        {
            MGB_LOCK_GUARD(m_mtx);
            m_worker_tids.push_back(std::this_thread::get_id());
        }

        if (m_name.valid()) {
            sys::set_thread_name(ssprintf("%s:%zu", m_name->c_str(), id));
        }

        for (;;) {
            Task task;
            for (;;) {
                std::unique_lock<std::mutex> lk(m_mtx);
                if (m_should_stop)
                    return;
                if (!m_tasks.empty()) {
                    task = std::move(m_tasks.front());
                    m_tasks.pop_front();
                    break;
                }

                m_cv_more_task.wait(lk);
            }
            task();
        }
    }

public:
    using Future = std::future<R>;

    /*!
     * \param name thread name for the workers
     */
    FutureThreadPool(const Maybe<std::string>& name = None) : m_name{name} {}

    ~FutureThreadPool() { stop(); }

    /*!
     * \brief launch a task with given function and args
     */
    template <typename Func, typename... Args>
    Future launch(Func&& func, Args&&... args) {
        auto bfunc = std::bind(std::forward<Func>(func), std::forward<Args>(args)...);

        MGB_LOCK_GUARD(m_mtx);
        m_tasks.emplace_back(std::move(bfunc));