std::call_once多线程初始化的使用

对于程序中有些对象只需要初始化一次，在多线程中，我们一般使用双重检查锁，代码如下：

void double_checked_locking()
{
    if(!resource_ptr)
    {
        std::lock_guard<std::mutex> lock(resource_mutex);
        if(!resource_ptr)
        {
            resource_ptr.reset(new some_resource);
        }
    }
    resource_ptr->do_something();
}

但是这样写比较麻烦，效率也不高。

C++11对于这种初始化增加了一个新的方式，代码如下：

std::shared_ptr<some_resource> resource_ptr;
std::once_flag resource_falg;

void init_resource()
{
    resource_ptr.reset(new some_resource);
}

void foo()
{
    std::call_once(resource_flag,init_resource);
    resource_ptr->do_something();
}

这种方式使用起来就方便很多。下面是针对类使用这种方式的代码：

class X
{
private:
    connection_info connection_details;
    connection_handle connection;
    std::once_flag connection_init_flag;
    
    void open_connection()
    {
        connection=connection_manager.open(connection_details);
    }
public:
    X(connection_info const& connection_details_):
        connection_details(connection_details_)
    {}

    void send_data(data_packet const& data)
    {
        std::call_once(connection_init_flag,&X::open_connection,this);
        connection.send_data(data);
    }

    data_packet receive_data()
    {
        std::call_once(connection_init_flag,&X::open_connection,this);
        return connection.receive_data();
    }
};