c++11多线程记录5： Unique Lock和延时初始化

https://www.youtube.com/user/BoQianTheProgrammer 视频网址

Unique Lock

unique_lock和lock_guard类似，都是mutex的wrapper类，但是前者更加灵活

lock_guard没有unlock方法，unique_lock可以调用unlock
unique_lock可以延时调用lock方法，lock_guard不行
unique_lock不可复制、可移动，lock_guard不可复制、不可移动

// 1

...

std::unique_lock<std::mutex> locker(mu);

g_num ++;

locker.unlock();

...

// 2

...

std::unique_lock<std::mutex> locker(mu, std::defer_lock);

...

locker.lock();

g_num++;

locker.unlock();

...

locker.lock();

g_num++;

locker.unlock();

...

// 3

...

std::unique_lock<std::mutex> locker2 = std::move(locker);

unique_lock并不能取代lock_guard

unique_lock的灵活性是有代价的，灵活的同时其本身所占空间也越大（时间性能上不了解）

有时候并不需要unique_lock的那些灵活性，只要用lock_guard即可

Lasy Initialization

先看下面一段代码

class LogFile {

    std::mutex _mu;

    ofstream _f;

public:

     LogFile() {

        _f.open("log.txt");

    }

    void func(string id, int v) {

        std::unique_lock<mutex> locker(_mu);

        _f << id << ", " << v << endl;

    }

}

打印日志的类，在构造函数里打开log.txt

但是有可能自始至终都没有打印过日志（调用func），那么_f.open就没有必要调用

可以考虑在func中调用_f.open，如下

class LogFile {

    std::mutex _mu;

    ofstream _f;

public:

    LogFile() {

       // _f.open("log.txt");

    }

    void func(string id, int v) {

        if (!_f.is_open()) {

            _f.open("log.txt");

        }

        std::unique_lock<mutex> locker(_mu);

        _f << id << ", " << v << endl;

    }

}

线程安全

这时就要考虑LogFile::func的线程安全问题（针对资源对象_f)），按照前面的方法，通过mutex来控制_f的使用

class LogFile {

    std::mutex _mu_open;

    ofstream _f;

public:

     LogFile() {  }

    void func(string id, int v) {

        if (!_f.is_open()) {

            std::unique_lock<mutex> locker(_mu_open);

            _f.open("log.txt");

        }

        ...

    }

}

上面这段代码并没有做到线程安全。场景假设：

线程A和线程B同时进到 if (_f.is_open())，这时文件并没有打开过，所以都通过了if判断，

接着A,B都会调用获取mutex，假设A先获取，然后A调用open打开文件，然后释放mutex，

接着B就会获取mutex，然后会再调用一次open。

两次打开一个文件！

不仅仅_f.open需要同步，_f.is_open也需要同步：

...

std::unique_lock<mutex> locker2(_mu_open);

if (_f.is_open()) {

    _f.open("log.txt");

}

locker2.unlock();

...

但是这时又会有另外一个问题，每次func函数被调用时都会有一次mutex获取的行为，一定程度上会影响程序的并发性

std::once_flag和std::call_once

针对上面那个问题，c++提供了std::once_flag来解决：

class LogFile {

    std::once_flag _flag;

    ofstream _f;

public:

     LogFile() {  }

    void func(string id, int v) {

        std::call_once(_flag, [&](){_f.open("log.txt");});

        ...

    }

}

上面代码里的lambda函数仅会被一个线程调用一次！

巴特西