c++11 - 将 std::promise 对象存储在 std::pair 中

Question

我正在研究几个 C++11 工作队列类。第一类，command_queue 是一个多生产者单消费者工作队列。多个线程可以发布命令，单个线程循环调用“wait()”和“pop_back()”来处理这些命令。

第二个类，Actor 使用 command_queue 并实际上提供了一个消费者线程...除此之外，其想法是 post() 将返回一个 future，以便客户端可以阻塞直到命令被处理，或者继续运行(actor还添加了结果类型的想法)。为了实现这一点，我尝试将 std::promise 存储在工作队列中的 std::pair 中。我相信我已经相当接近了，但是我在下面的 _entry_point 函数中遇到了问题......具体来说，当我试图将 std::pair 从命令队列中取出时，我得到了“使用已删除function”编译器错误...我将从编译器得到的实际错误放在代码下方(您应该能够将其保存到文本文件并自己编译，它是独立的 c++11 代码) .

#include <mutex>
#include <condition_variable>
#include <future>
#include <list>
#include <stdio.h>

template<class T>
class command_queue
{

public:
    command_queue() = default;
    command_queue( const command_queue& ) = delete;
    virtual ~command_queue() noexcept = default;

    command_queue& operator = ( const command_queue& ) = delete;

    void start()
    {
        std::unique_lock<std::recursive_mutex> g( _queueLock );
        _started = true;
    }

    bool started()
    {
        return _started;
    }

    void stop()
    {
        std::unique_lock<std::recursive_mutex> g( _queueLock );
        _started = false;
        _queueCond.notify_one();
    }

    void post_front( const T& cmd )
    {
        std::unique_lock<std::recursive_mutex> g( _queueLock );
        _queue.push_front( cmd );
        _queueCond.notify_one();
    }

    void post_front( T&& cmd )
    {
        std::unique_lock<std::recursive_mutex> g( _queueLock );
        _queue.push_front( cmd );
        _queueCond.notify_one();
    }

    void wait()
    {
        std::unique_lock<std::recursive_mutex> g( _queueLock );
        _queueCond.wait( g, [this](){return !this->_queue.empty() ? true : !this->_started;});
    }

    T pop_back()
    {
        std::unique_lock<std::recursive_mutex> g( _queueLock );
        auto val = _queue.back();
        _queue.pop_back();
        return val;
    }

private:
    std::recursive_mutex _queueLock;
    std::condition_variable_any _queueCond;
    std::list<T> _queue;
    bool _started = false;
};

template<class T, class U>
class actor
{
public:
    actor() :
        _started( false ),
        _thread(),
        _queue()
    {
    }

    actor( const actor& ) = delete;

    virtual ~actor() noexcept
    {
        if( _started )
            stop();
    }

    actor& operator = ( const actor& ) = delete;

    void start()
    {
        _started = true;

        _queue.start();

        _thread = std::thread( &actor<T,U>::_entry_point, this );
    }

    void stop()
    {
        _started = false;

        _queue.stop();

        _thread.join();
    }

    std::future<U> post( const T& cmd )
    {
        std::promise<U> p;
        std::future<U> waiter = p.get_future();

        _queue.post_front( std::pair<T,std::promise<U>>(cmd, std::move(p)) );

        return waiter;
    }

    virtual U process( const T& cmd ) = 0;

protected:
    void _entry_point()
    {
        while( _started )
        {
            _queue.wait();

            if( !_started )
                continue;

            std::pair<T,std::promise<U>> item = _queue.pop_back();

            item.second.set_value( process( item.first ) );
        }
    }

    bool _started;
    std::thread _thread;
    command_queue<std::pair<T,std::promise<U>>> _queue;
};

class int_printer : public actor<int,bool>
{
public:
    virtual bool process( const int& cmd ) override
    {
        printf("%d",cmd);
        return true;
    }
};

using namespace std;

int main( int argc, char* argv[] )
{
//    std::promise<bool> p;
//    list<std::pair<int,std::promise<bool>>> promises;
//    promises.push_back( make_pair<int,std::promise<bool>>(10,std::move(p)) );

    int_printer a;
    a.start();
    future<bool> result = a.post( 10 );
    a.stop();
}

[developer@0800275b874e projects]$ g++ -std=c++11 pf.cpp -opf -lpthread
pf.cpp: In instantiation of ‘T command_queue<T>::pop_back() [with T = std::pair<int, std::promise<bool> >]’:
pf.cpp:133:65:   required from ‘void actor<T, U>::_entry_point() [with T = int; U = bool]’
pf.cpp:99:9:   required from ‘void actor<T, U>::start() [with T = int; U = bool]’
pf.cpp:163:13:   required from here
pf.cpp:60:32: error: use of deleted function ‘constexpr std::pair<_T1, _T2>::pair(const std::pair<_T1, _T2>&) [with _T1 = int; _T2 = std::promise<bool>]’
In file included from /usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility:72:0,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/tuple:38,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/mutex:39,
                 from pf.cpp:2:
/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:119:17: note: ‘constexpr std::pair<_T1, _T2>::pair(const std::pair<_T1, _T2>&) [with _T1 = int; _T2 = std::promise<bool>]’ is implicitly deleted because the default definition would be ill-formed:
/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:119:17: error: use of deleted function ‘std::promise<_Res>::promise(const std::promise<_Res>&) [with _Res = bool]’
In file included from pf.cpp:4:0:
/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/future:963:7: error: declared here
In file included from /usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/list:64:0,
                 from pf.cpp:5:

Answer 1

Promise 是不可复制的(这是有道理的 - 它们代表了一种独特的状态)。您需要在多个地方使用 std::move 来转移 Promise 的唯一所有权。

具体来说，您的自制队列类需要允许移动，例如

auto val = std::move(_queue.back());
_queue.pop_back();
return val;