std mutex 用对象锁住
时间: 2023-06-19 13:10:47 浏览: 61
`std::mutex` 是 C++11 引入的一个线程同步工具,用于保护共享资源的访问。你可以使用 `std::mutex` 对象来锁住一个代码块,以确保同一时间只有一个线程可以访问该代码块。
下面是一个使用 `std::mutex` 的示例代码:
```cpp
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 创建一个 mutex 对象
void print_thread_id(int id)
{
mtx.lock(); // 锁住代码块
std::cout << "Thread #" << id << " is running.\n";
mtx.unlock(); // 解锁代码块
}
int main()
{
std::thread threads[5];
for (int i = 0; i < 5; ++i)
threads[i] = std::thread(print_thread_id, i+1);
for (auto& th : threads) th.join();
return 0;
}
```
在上面的示例中,我们创建了一个 `std::mutex` 对象 `mtx`,然后在 `print_thread_id` 函数中使用 `mtx.lock()` 和 `mtx.unlock()` 来锁住和解锁代码块。这样,在任何时刻,只有一个线程可以执行被锁住的代码块。
相关问题
std mutex 用guard锁住
使用 std::lock_guard<std::mutex> 类模板可以方便地锁住 std::mutex,从而保证线程安全。
std::lock_guard 是一个类模板,它接受一个互斥量作为模板参数。在创建 std::lock_guard 对象时,它会自动锁住该互斥量,并在其作用域结束时自动释放锁。
例如,下面的代码片段展示了使用 std::lock_guard<std::mutex> 来锁住一个互斥量:
```c++
#include <mutex>
std::mutex my_mutex;
void foo() {
std::lock_guard<std::mutex> lock(my_mutex);
// 在这里执行需要保护的代码
}
```
在上面的代码中,创建了一个名为 lock 的 std::lock_guard 对象,并将 my_mutex 作为参数传递给它的构造函数。在 lock 对象的生命周期内,my_mutex 被锁住,从而保证了在 foo 函数中需要保护的代码的线程安全性。当 lock 对象的生命周期结束时,它的析构函数会自动释放 my_mutex,从而解锁它。
总之,使用 std::lock_guard 可以让锁的使用更加简单和安全,避免了手动加锁和解锁的繁琐操作,同时也能够避免由于忘记解锁而导致的死锁等问题。
std mutex 锁住
在 C++ 中,std::mutex 是一种用于线程同步的互斥量。当一个线程正在访问某个共享资源时,可以使用 std::mutex 对这个资源进行加锁,以确保其他线程在此期间无法访问该资源,从而避免数据竞争的问题。
使用 std::mutex 一般需要以下步骤:
1. 定义一个 std::mutex 对象;
2. 在需要保护的代码块前调用 std::mutex 的 lock() 方法,以锁住互斥量;
3. 在保护的代码块执行完毕后,调用 std::mutex 的 unlock() 方法,以释放互斥量。
例如,下面是一个简单的示例代码,展示了如何使用 std::mutex 来保护一个共享变量:
```c++
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int shared_var = 0;
void increment_shared_var(int id) {
for (int i = 0; i < 100000; ++i) {
mtx.lock();
++shared_var;
mtx.unlock();
}
}
int main() {
std::thread t1(increment_shared_var, 1);
std::thread t2(increment_shared_var, 2);
t1.join();
t2.join();
std::cout << "shared_var = " << shared_var << std::endl;
return 0;
}
```
在这个例子中,我们定义了一个全局的 std::mutex 对象 mtx 和一个共享变量 shared_var,然后启动两个线程来分别对 shared_var 进行 100000 次自增操作。在每次自增操作前,我们都使用 mtx.lock() 方法来锁住互斥量,以确保只有一个线程能够访问共享变量。在自增操作完成后,我们再调用 mtx.unlock() 方法来释放互斥量。
运行这个程序,你会发现最终输出的 shared_var 值为 200000,这说明两个线程对共享变量进行了正确的并发更新,并且互斥量起到了保护作用。
相关推荐
![zip](https://img-home.csdnimg.cn/images/20210720083736.png)
![pdf](https://img-home.csdnimg.cn/images/20210720083512.png)
![zip](https://img-home.csdnimg.cn/images/20210720083736.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)