c++ - std::lock_guard 示例，解释其工作原理

Question

我在我的项目中遇到了一个问题，即需要线程之间就可以写入的资源进行通信，因此必须进行同步。但是，除了基本级别之外，我对同步一无所知。

考虑此链接中的最后一个示例:http://www.bogotobogo.com/cplusplus/C11/7_C11_Thread_Sharing_Memory.php

#include <iostream>
#include <thread>
#include <list>
#include <algorithm>
#include <mutex>

using namespace std;

// a global variable
std::list<int>myList;

// a global instance of std::mutex to protect global variable
std::mutex myMutex;

void addToList(int max, int interval)
{
    // the access to this function is mutually exclusive
    std::lock_guard<std::mutex> guard(myMutex);
    for (int i = 0; i < max; i++) {
        if( (i % interval) == 0) myList.push_back(i);
    }
}

void printList()
{
    // the access to this function is mutually exclusive
    std::lock_guard<std::mutex> guard(myMutex);
    for (auto itr = myList.begin(), end_itr = myList.end(); itr != end_itr; ++itr ) {
        cout << *itr << ",";
    }
}

int main()
{
    int max = 100;

    std::thread t1(addToList, max, 1);
    std::thread t2(addToList, max, 10);
    std::thread t3(printList);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

该示例演示了三个线程(两个写入者和一个读取者)如何访问公共(public)资源(列表)。

使用了两个全局函数:一个由两个写入线程使用，一个由读取线程使用。这两个函数都使用 lock_guard 来锁定相同的资源，即列表。

现在这就是我无法理解的内容:阅读器在与两个编写器线程不同的范围内使用锁，但仍锁定相同的资源。这怎么行？我对互斥锁的有限理解非常适合编写器功能，您有两个线程使用完全相同的功能。我可以理解，在您即将进入保护区时进行检查，如果其他人已经在里面，您等待。

但是当范围不同时呢？这表明存在某种比进程本身更强大的机制，某种运行时环境阻止“迟到”线程的执行。但我认为 C++ 中没有这样的东西。所以我很茫然。

这里到底发生了什么？

Answer 1

让我们看一下相关行:

std::lock_guard<std::mutex> guard(myMutex);

请注意，lock_guard 引用了 global 互斥锁 myMutex。也就是说，所有三个线程都使用相同的互斥锁。 lock_guard 的作用本质上是这样的:

• 在构造时，它会锁定 myMutex 并保留对它的引用。
• 在销毁时(即当守卫的作用域离开时)，它会解锁 myMutex。

互斥体总是同一个，它与作用域无关。 lock_guard 的目的只是让您更轻松地锁定和解锁互斥锁。例如，如果您手动 lock/unlock，但您的函数在中间某处抛出异常，则它永远不会到达 unlock 语句。因此，以手动方式您必须确保互斥锁始终解锁。另一方面，只要函数退出，lock_guard 对象就会自动销毁——不管它是如何退出的。