Question

我想创建一个用于实验目的的线程池（以及有趣的因素）。它应该能够处理各种各样的任务（所以我可以在以后的项目中使用它）。

在我的线程池类中，我需要某种任务队列。由于标准库从C ++ 11标准开始提供std::packaged_task，因此我的队列看起来像std::deque<std::packaged_task<?()> > task_queue，因此客户端可以通过某种公共接口函数将std::packaged_task推送到队列中（然后将通过条件变量通知池中的一个线程来执行它，等等。）

我的问题与deque中std::packaged_task<?()> s的模板参数有关。

函数签名?()应该能够处理任何类型/数量的参数，因为客户端可以执行以下操作：

std::packaged_task<int()> t(std::bind(factorial, 342)); thread_pool.add_task(t);

所以我不必处理参数的类型/数量。

但是返回值应该是什么？（因此问号）

如果我将整个线程池类作为模板类，则为一个实例它只能处理具有特定签名的任务（如std::packaged_task<int()>）。

我希望一个线程池对象能够处理任何类型的任务。
如果我使用std::packaged_task<void()>并调用该函数返回一个整数，或任何东西，然后是未定义的行为。

Answer 1

所以困难的是packaged_task<R()>只是移动的，否则你可以把它扔进std::function<void()>，并在你的线程中运行它们。

有几种解决方法。

首先，可笑的是，使用packaged_task<void()>来存储packaged_task<R()>。我建议不要这样做，但确实有效。 ;）（operator()上packaged_task<R()>的签名是什么？传递给packaged_task<void()>的对象所需的签名是什么？）

其次，将packaged_task<R()>包裹在shared_ptr中，将其捕获到带有签名void()的lambda中，将其存储在std::function<void()>中，然后完成。这有开销成本，但可能低于第一个解决方案。

最后，编写自己的仅移动函数包装器。对于签名void()，它很短：

struct task {
  template<class F,
    class dF=std::decay_t<F>,
    class=decltype( std::declval<dF&>()() )
  >
  task( F&& f ):
    ptr(
      new dF(std::forward<F>(f)),
      [](void* ptr){ delete static_cast<dF*>(ptr); }
    ),
    invoke([](void*ptr){
      (*static_cast<dF*>(ptr))();
    })
  {}
  void operator()()const{
    invoke( ptr.get() );
  }
  task(task&&)=default;
  task&operator=(task&&)=default;
  task()=default;
  ~task()=default;
  explicit operator bool()const{return static_cast<bool>(ptr);}
private:
  std::unique_ptr<void, void(*)(void*)> ptr;
  void(*invoke)(void*) = nullptr;
};

简单。以上内容可以为任何类型packaged_task<R()>存储R，并在以后调用它们。

这有相对最小的开销 - 它应该比std::function便宜，至少我已经看过的实现 - 除了它不存储小型函数对象的SBO（小缓冲区优化）在内部而不是在堆上。

如果需要，可以使用小缓冲区优化来改进unique_ptr<> ptr容器。

Answer 2

我碰巧有一个实现正是如此。我的做法是将std::packaged_task对象包装在一个抽象返回类型的结构中。将任务提交到线程池的方法将返回结果的未来。

这种工作，但是由于每个任务所需的内存分配，它不适合非常短且非常频繁的任务（我试图用它来并行化流体模拟的块并且开销也是如此）高，大约为几毫秒，324个任务。）

关键部分是这个结构：

struct abstract_packaged_task
{
    template <typename R>
    abstract_packaged_task(std::packaged_task<R> &&task):
        m_task((void*)(new std::packaged_task<R>(std::move(task)))),
        m_call_exec([](abstract_packaged_task *instance)mutable{
            (*(std::packaged_task<R>*)instance->m_task)();
        }),
        m_call_delete([](abstract_packaged_task *instance)mutable{
            delete (std::packaged_task<R>*)(instance->m_task);
        })
    {

    }

    abstract_packaged_task(abstract_packaged_task &&other);

    ~abstract_packaged_task();

    void operator()();

    void *m_task;
    std::function<void(abstract_packaged_task*)> m_call_exec;
    std::function<void(abstract_packaged_task*)> m_call_delete;
};

如您所见，它通过使用带有std::function和void*的lambdas来隐藏类型依赖关系。如果你知道所有可能出现的std::packaged_task对象的最大大小（我还没有检查大小是否依赖于R），你可以尝试通过删除内存分配来进一步优化它。

然后，线程池中的提交方法执行此操作：

template <typename R>
std::future<R> submit_task(std::packaged_task<R()> &&task)
{
    assert(m_workers.size() > 0);
    std::future<R> result = task.get_future();
    {
        std::unique_lock<std::mutex> lock(m_queue_mutex);
        m_task_queue.emplace_back(std::move(task));
    }
    m_queue_wakeup.notify_one();
    return result;
}

其中m_task_queue是std::deque个abstract_packaged_task结构。 m_queue_wakeup是一个std::condition_variable来唤醒工作线程以接收任务。工作线程实现非常简单：

void ThreadPool::worker_impl()
{
    std::unique_lock<std::mutex> lock(m_queue_mutex, std::defer_lock);
    while (!m_terminated) {
        lock.lock();
        while (m_task_queue.empty()) {
            m_queue_wakeup.wait(lock);
            if (m_terminated) {
                return;
            }
        }
        abstract_packaged_task task(std::move(m_task_queue.front()));
        m_task_queue.pop_front();
        lock.unlock();

        task();
    }
}

您可以查看我的github上的完整source code和corresponding header。

在C ++ 11

2 个答案: