小编Dec*_*her的帖子

std :: promise提供了一种设置值(类型为T)的方法,稍后可以通过关联的std :: future对象读取该值

1. 这两者究竟如何相关联？

2. 我的担忧是否合理,未来会与错误的承诺结合？

更新:来自行动中的并发的示例...(但代码无法编译)

#include <future>
void process_connections(connection_set& connections)
{
    while(!done(connections)){
        for(connection_iterator
        connection=connections.begin(),end=connections.end();
        connection!=end;
        ++connection)
        {
            if(connection->has_incoming_data()){
                data_packet data=connection->incoming();
                std::promise<payload_type>& p=
                connection->get_promise(data.id);
                p.set_value(data.payload);
            }
            if(connection->has_outgoing_data()){
                outgoing_packet data=
                connection->top_of_outgoing_queue();
                connection->send(data.payload);
                data.promise.set_value(true);
            }
        }
    }
}

我正在阅读c ++中的并发编程,并遇到了这段代码.这本书提到了令人讨厌的竞争条件的可能性.

void undefined_behaviour_with_double_checked_locking(){

if(!resource_ptr){        //<1>
    std::lock_guard<std::mutex> lk(resource_mutex);
    if(!resource_ptr){        //<2>   
        resource_ptr.reset(new some_resource);        //<3>
    }
}

resource_ptr->do_something();        //<4>

}

这是书中解释的引用.但是,我只是想出一个真实的例子.我想知道这里是否有人可以帮助我.

不幸的是,这种模式是臭名昭着的原因:它有可能出现令人讨厌的竞争条件,因为锁定<1>外的读取与锁定<3>内的另一个线程所做的写入不同步.因此,这会创建一个竞争条件,不仅包括指针本身,还包括指向的对象; 即使一个线程看到另一个线程写入的指针,它也可能看不到新创建的some_resource实例,导致调用do_something()<4>对不正确的值进行操作.