开发 C++具有“futures”的并发库或类似的范式

Question

我正在开发一个 C++ 项目，需要在线程池中运行许多作业。这些作业很容易失败，这意味着我需要知道每个作业完成后如何终止。作为一名 Java 程序员，我喜欢使用“futures”或类似范例的想法，类似于 Java util.concurrent 包中的各种类。

我有两个问题：第一，C++ 中是否已经存在类似的东西（我在 Boost 中没有找到任何东西，但也许我寻找得不够努力）；其次，这对于 C++ 来说是一个明智的想法吗？

我在这里找到了一个我想要完成的简单示例：

http://www.boostcookbook.com /Recipe:/1234841

这种方法有意义吗？

Answer 1

Future 都存在于即将推出的标准 (C++0x) 和内部 boost 中。请注意，虽然主名称 future 是相同的，但您需要阅读文档才能找到其他类型并理解语义。我不了解 Java future，所以我无法告诉您它们的不同之处（如果有的话）。

boost 中的库是由 Anthony Williams 编写的，我相信他也参与了该部分的定义标准。他还撰写了 C++ 并发实践，其中包括对 future 的精彩描述、任务、承诺和相关对象。如果您有兴趣，他的公司还销售完整且最新的 C++0x 线程库实现。

Answer 2

Boost 实现了 future 和其他线程工具。

请注意，当您在 boost::unique_future 上调用 get() 方法时，它将重新抛出异步执行期间可能存储在其中的任何异常。

我建议你做类似的事情：

#pragma once

#include <tbb/concurrent_queue.h>

#include <boost/thread.hpp>
#include <boost/noncopyable.hpp>

#include <functional>

namespace internal
{
    template<typename T>
    struct move_on_copy
    {
        move_on_copy(const move_on_copy<T>& other) : value(std::move(other.value)){}
        move_on_copy(T&& value) : value(std::move(value)){}
        mutable T value;
    };

    template<typename T>
    move_on_copy<T> make_move_on_copy(T&& value)
    {
        return move_on_copy<T>(std::move(value));
    }
}

class executor : boost::noncopyable
{
    boost::thread thread_;

    tbb::concurrent_bounded_queue<std::function<void()>> execution_queue_;

    template<typename Func>
    auto create_task(Func&& func) -> boost::packaged_task<decltype(func())> // noexcept
    {   
        typedef boost::packaged_task<decltype(func())> task_type;

        auto task = task_type(std::forward<Func>(func));            

        task.set_wait_callback(std::function<void(task_type&)>([=](task_type& my_task) // The std::function wrapper is required in order to add ::result_type to functor class.
        {
            try
            {
                if(boost::this_thread::get_id() == thread_.get_id())  // Avoids potential deadlock.
                    my_task();
            }
            catch(boost::task_already_started&){}
        }));

        return std::move(task);
    }

public:

    explicit executor() // noexcept
    {
        thread_ = boost::thread([this]{run();});
    }

    ~executor() // noexcept
    {   
        execution_queue_.push(nullptr); // Wake the execution thread.
        thread_.join();
    }

    template<typename Func>
    auto begin_invoke(Func&& func) -> boost::unique_future<decltype(func())> // noexcept
    {   
        // Create a move on copy adaptor to avoid copying the functor into the queue, tbb::concurrent_queue does not support move semantics.
        auto task_adaptor = internal::make_move_on_copy(create_task(func));

        auto future = task_adaptor.value.get_future();

        execution_queue_.push([=]
        {
            try{task_adaptor.value();}
            catch(boost::task_already_started&){}
        });

        return std::move(future);       
    }

    template<typename Func>
    auto invoke(Func&& func) -> decltype(func()) // noexcept
    {
        if(boost::this_thread::get_id() == thread_.get_id())  // Avoids potential deadlock.
            return func();

        return begin_invoke(std::forward<Func>(func), prioriy).get();
    }

private:

    void run() // noexcept
    {
        while(true)
        {
            std::function<void()> func;
            execution_queue_.pop(func); 
                    if(!func)
                       break;
            func();
        }
    }   
};

Answer 3

C++ 模板比 Java 泛型限制更少，因此“Future”可以轻松地与它们和线程同步原语一起移植。至于支持这种机制的现有库，希望其他人知道。