我正在尝试构建一个需要由一个线程执行并且可以由多个线程提供的函数的工作队列。为此，我计划使用 boost::packaged_task 和 boost::unique_future。这个想法是你会做的:

Foo 值 = queue.add(myFunc).get();

这会阻塞，直到函数被执行。所以 queue.add(...) 接受一个 boost::function，并返回一个 boost::unique_future。然后在内部它使用 boost::function 为其构造函数创建一个 boost::packaged_task。

我遇到的问题是 boost::function<...> 每次都不一样。具体来说，它的返回值会改变(但是，函数永远不会接受任何参数)。因此，我必须有一个看起来像这样的添加函数:

template <typename ResultType>
boost::unique_future<ResultType> add(boost::function<ResultType ()> f) {
   boost::packaged_task<boost::function<ResultType ()> > task(f);
   queue.push_back(task);
   return task.get_future();
}

好吧，这看起来还不错，但后来我遇到了如何定义“队列”的问题。我想我别无选择，只能使用 boost::any，因为类型不会是常量:

std::list<boost::any> queue; // note: I'm not concerned with thread-safety yet

但是当我尝试实现我的 executeSingle 时遇到了一个问题(只从队列中取出一个项目来执行):

void executeSingle() {
    boost::any value = queue.back();
    boost::packaged_task<?> task = boost::packaged_task<?>(boost::move(value));
    // actually execute task
    task();
    queue.pop_back();
}

“？”表示我不确定的事情。我无法使用模板调用 executeSingle，因为它是从单独的线程调用的。我尝试使用 boost::any，但出现错误:

  conversion from 'boost::any' to non-scalar type  boost::detail::thread_move_t<boost:thread>' requested.

有趣的是，此时我其实并不关心 packaged_task 的返回类型，我只想执行它，但我可以弄清楚模板细节。

任何见解将不胜感激!

最佳答案

你应该存储 boost::function<void()>的。注意 boost::packaged_task<R>::operator()不返回任何东西；它填充相关的 boost::future .事实上，即使它返回了一些东西，你仍然可以使用 boost::function<void()>因为您仍然对返回值不感兴趣:您只关心调用 queue.back()() .如果是这样的话boost::function<void()>::operator()会负责为您丢弃返回值。

请注意，您可能想要更改 add 的签名在通用类型上模板化的方法 Functor而不是 boost::function ，并使用 boost::result_of获取 boost::packaged_task 的结果类型.

我的整体建议:

template<typename Functor>
boost::future<typename boost::result_of<Functor()>::type>
queue::add(Functor functor) // assuming your class is named queue
{
    typedef typename boost::result_of<Functor()>::type result_type;
    boost::packaged_task<result_type> task(functor);
    boost::unique_future<result_type> future = task.get_future();
    internal_queue.push_back(boost::move(task)); // assuming internal_queue member
    return boost::move(future);
}

void
queue::executeSingle()
{
    // Note: do you really want LIFO here?
    queue.back()();
    queue.pop_back();
}

编辑

如何处理内部的移动语义 queue::add

typedef typename boost::result_of<Functor()>::type result_type;
typedef boost::packaged_task<result_type> task_type;
boost::shared_ptr<task_type> task = boost::make_shared<task_type>(functor);
boost::unique_future<result_type> future = task->get_future();

/* boost::shared_ptr is possibly move-enabled so you can try moving it */
internal_queue.push_back( boost::bind(dereference_functor(), task) );

return boost::move(future);

哪里dereference_functor可能是:

struct dereference_functor {
    template<typename Pointer>
    void
    operator()(Pointer const& p) const
    {
        (*p)();
    }
};

您也可以替换为 bind表达更清晰

boost::bind(&task_type::operator(), task)

这也不需要自定义仿函数。但是，如果 task_type::operator() 有多个重载这可能需要消除歧义；如果 Boost.Thread 中的 future 更改引入过载，代码也可能会中断。

关于c++ - 如何创建一个队列，其中包含 boost::packaged_task<> 以及返回任意类型的函数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5889532/