(5)Unique Lock和Lazy Initialization

最新推荐文章于 2025-07-23 09:51:44 发布

原创最新推荐文章于 2025-07-23 09:51:44 发布 · 277 阅读

0 ·

CC 4.0 BY-SA版权

C++11多线程学习笔记专栏收录该内容

8 篇文章

订阅专栏

本文介绍了C++中三种定义互斥锁的方法：直接加锁、使用std::lock_guard及std::unique_lock，并通过示例展示了如何利用unique_lock实现更灵活的锁管理以及如何确保文件操作的线程安全性。

前面我们已经介绍了两种定义互斥锁的方式：
(1)mu.lock()
(2)std::lock_guard<std::mutex> locker(mu)
接着我们介绍第三种方式，
(3)std::unique_lock<mutex> locker(mu,std::defer_lock);
其中参数std::defer_lock表明locker延迟锁定，在之后我们可以为想要进行锁住的代码片段随时加锁，并可以多次加锁．
locker.lock();
…
locker.unlock();//形如这样的代码片段
和lock_guard相比unique_lock的弹性更大，更加灵活．而且，这两种都不能被拷贝，只有unique_lock能进行移动．移动以后，mutex的控制权会转移．
虽然，unique_lock的功能比lock_guard强大，但是是以消耗更多计算机性能为前提的，因此之后我们需要权衡来进行选择．

#include <iostream>
#include <thread>
#include <mutex>
#include <fstream>
std::mutex mu;

using namespace std;
class LogFile
{
    std::mutex m_mutex;
    std::ofstream f;
public:
    LogFile()
    {
        f.open("log.txt");
    }
    void shared_print(std::string id,int value)
    {
        std::unique_lock<std::mutex> locker(mu,std::defer_lock);
        f << "From " << id << ":" << value << endl;
    }
};

void function_1(LogFile& log)
{
    for(int i=0;i>-100;i--)
        log.shared_print(std::string("From t1"),i);
}

int main()
{
    LogFile log;
    std::thread t1(function_1, std::ref(log));
    for(int i=0;i<100;++i)
        log.shared_print(std::string("From main"),i);
    t1.join();
    return 0;
}

然后介绍的是Lazy Initialization．
在上面的代码中，我们可以发现，在构造LogFile类的时候，其构造函数总会打开我们的log.txt,因为只有我们需要写入或读取数据的时候，打开文件才是有效的，所以为了避免无谓的操作，我们现进行改进．代码如下所示：

void shared_print(std::string id,int value)
{
      if(!f.is_open())
      {
            f.open(“log.txt”);
      }
      std::unique_lock locker(mu,std::defer_lock);
      f << “From ” << id << “:” << value << endl;
}

然后，为了是该代码段线程安全，我们需要加锁,即用mutex同步文件打开操作．

class LogFile
{
    std::mutex m_mutex_open;
    std::mutex m_mutex;
    std::ofstream f;
public:
    LogFile()
    {
        f.open("log.txt");
    }
    void shared_print(std::string id,int value)
    {
        if(!f.is_open())
        {
            std::unique_lock<std::mutex> locker2(mu_open,std::defer_lock);
            f.open("log.txt");
        }
        std::unique_lock<std::mutex> locker(mu,std::defer_lock);
        f << "From " << id << ":" << value << endl;
    }
};

此时，仍然没有满足线程安全！因为有可能会有两个线程(或者多个线程)来打开文件多次．所以这里并不是绝对的线程安全．那该怎么解决呢？解决方式就是同步is_open()函数．

class LogFile
{
    std::mutex m_mutex_open;
    std::mutex m_mutex;
    std::ofstream f;
public:
    LogFile()
    {
        f.open("log.txt");
    }
    void shared_print(std::string id,int value)
    {
        {
            std::unique_lock<std::mutex> locker2(mu_open,std::defer_lock);
            if(!f.is_open())
                f.open("log.txt");
        }
        std::unique_lock<std::mutex> locker(mu,std::defer_lock);
        f << "From " << id << ":" << value << endl;
    }
};

此时，这段代码就是线程安全的了，但是又引入了另外一个问题,就是在shared_print()函数中需要不断的加锁和解锁，消耗计算资源．其实，标准库中有一个类型可以帮助我们解决这个问题，见代码：

class LogFile
{
    std::once_flag m_flag;
    std::mutex m_mutex;
    std::ofstream f;
public:
    LogFile()
    {
        f.open("log.txt");
    }
    void shared_print(std::string id,int value)
    {
        std::call_once(m_flag,[&](){f.open("log.txt");});//该语句可以确保lambda函数只被一个线程执行一次
        std::unique_lock<std::mutex> locker(mu,std::defer_lock);
        f << "From " << id << ":" << value << endl;
    }
};