在c++；并发性 尝试用C++理解并发编程的细节。遇到了这段代码，并且理解了其中的一行代码。详情见附件: template<typename T> class threadsafe_stack { private: std::stack<T> data; mutable std::mutex m; public: threadsafe_stack(){} threadsafe_stack(const threadsafe_stack& other) { std::lock_guard<std::mutex> lock(other.m); //////////////////why <1>locking other.m not this->m <2> or locking both data=other.data; } // some other codes } 模板 类线程安全\u堆栈 { 私人： std：：堆栈数据； 可变std:：mutexm； 公众： 线程安全_堆栈（）{} 线程安全_堆栈（常量线程安全_堆栈和其他） { 标准：锁和防护锁（其他m）； //////////////////为什么要锁定其他.m而不是此->m或同时锁定两者 数据=其他数据； } //其他一些代码 }

这是因为类

threadsafe\u堆栈

的

This

实例是第一次构造的，因此您可以确保没有其他人访问它的字段，因此它不需要使用

This->mutex

。但是，当时可能有其他人在使用

other

实例，因此最好使用该互斥来保护

other

的

数据

字段不被并发访问

也就是说，在基于其他实例构造对象时，会调用复制构造函数（您看到的代码），例如：

threadsafe_stack copy_of_stack{ original_stack };

现在，在复制构造函数的执行完成之前，没有其他人能够在

copy\u of_stack

实例的上下文中调用方法

每个

threadsafe_stack

的互斥体字段旨在防止并发访问互斥体所属实例的内容

现在，假设有另一个线程在

original_stack

实例上运行：

while (true)
{
    original_stack.push(123);
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

其中，

push

方法如下所示：

void threadsafe_stack<T>::push(const T& value)
{
    std::lock_guard<std::mutex> lock{ this->m };
    data.push(value);
}

void threadsafe_stack:：push（常量T和值）
{
锁{this->m}；
数据推送（值）；
}

---

如您所见，每个

push

操作都保护它自己的

数据

字段。

copy\u of_stack

实例的复制构造函数正在访问字段

data

的同一实例。使用相同的互斥锁使访问在访问

数据

字段方面相互排斥。换句话说：In

data=other.data此时没有其他人可以访问
数据
，但有人可以访问
其他.数据
，这就是为什么我们只锁定一个（该
其他
的）互斥锁。
这是因为类
线程安全栈
的
这个
实例是第一次构造的，因此，您可以确保没有其他人访问它的字段，因此它不需要使用
this->mutex
。但是，当时可能有其他人在使用
other
实例，因此最好使用该互斥来保护
other
的
数据
字段不被并发访问

也就是说，在基于其他实例构造对象时，会调用复制构造函数（您看到的代码），例如：

threadsafe_stack copy_of_stack{ original_stack };

现在，在复制构造函数的执行完成之前，没有其他人能够在
copy\u of_stack
实例的上下文中调用方法

每个
threadsafe_stack
的互斥体字段旨在防止并发访问互斥体所属实例的内容

现在，假设有另一个线程在
original_stack
实例上运行：

while (true)
{
    original_stack.push(123);
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

其中，
push
方法如下所示：

void threadsafe_stack<T>::push(const T& value)
{
    std::lock_guard<std::mutex> lock{ this->m };
    data.push(value);
}

void threadsafe_stack:：push（常量T和值）
{
锁{this->m}；
数据推送（值）；
}

如您所见，每个
push
操作都保护它自己的
数据
字段。
copy\u of_stack
实例的复制构造函数正在访问字段
data
的同一实例。使用相同的互斥锁使访问在访问
数据
字段方面相互排斥。换句话说：In
data=other.data此时没有其他人可以访问
数据
，但有人可以访问
其他.数据
，这就是为什么我们只锁定一个（该
其他
的）互斥锁。
这是因为类
线程安全栈
的
这个
实例是第一次构造的，因此，您可以确保没有其他人访问它的字段，因此它不需要使用
this->mutex
。但是，当时可能有其他人在使用
other
实例，因此最好使用该互斥来保护
other
的
数据
字段不被并发访问

也就是说，在基于其他实例构造对象时，会调用复制构造函数（您看到的代码），例如：

threadsafe_stack copy_of_stack{ original_stack };

现在，在复制构造函数的执行完成之前，没有其他人能够在
copy\u of_stack
实例的上下文中调用方法

每个
threadsafe_stack
的互斥体字段旨在防止并发访问互斥体所属实例的内容

现在，假设有另一个线程在
original_stack
实例上运行：

while (true)
{
    original_stack.push(123);
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

其中，
push
方法如下所示：

void threadsafe_stack<T>::push(const T& value)
{
    std::lock_guard<std::mutex> lock{ this->m };
    data.push(value);
}

void threadsafe_stack:：push（常量T和值）
{
锁{this->m}；
数据推送（值）；
}

如您所见，每个
push
操作都保护它自己的
数据
字段。
copy\u of_stack
实例的复制构造函数正在访问字段
data
的同一实例。使用相同的互斥锁使访问在访问
数据
字段方面相互排斥。换句话说：In
data=other.data此时没有其他人可以访问
数据
，但是有人可以访问
其他.数据
，这就是为什么我们只锁定一个（该
其他
的）互斥锁。
这是因为类
线程安全栈
的
实例正在为