定义
- 互斥量可以使用在各种方面,常用在对共享数据的读写上。如果有多线程读写一个数据,那么想要保证线程安全,必须对共享变量的读写上锁
头文件
#include <mutex>
类型
std::mutex
,最基本的Mutex类std::recursive_mutex
,递归Mutexstd::time_mutex
,限时Mutexstd::recursive_timed_mutex
,限时递归Mutex类std::shared_timed_mutex
,限时读写锁(C++14)std::shared_mutex
,读写锁(C++17)
std::mutex
构造函数
mutex() noexcept = default;
~mutex() = default;
mutex(const mutex&) = delete;
mutex& operator=(const mutex&) = delete;
std::mutex
不允许拷贝构造- 销毁互斥,若互斥被线程占有,或在占有
mutex
时线程被终止,则会产生未定义行为
用法
lock
锁定互斥,线程将锁住该互斥量,立即返回
无返回值
- 如果该互斥量当前没有被其他线程锁住,则调用线程将该互斥量锁住,直到调用unlock之前,该线程一直拥有该锁。
- 如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住,直到其他线程unlock该互斥量。
- 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。
PS:阻塞≠死锁,阻塞大概率会通畅,死锁一旦产生,则程序结束
try_lock
尝试锁住互斥量,立即返回
成功=True,反之=False
- 如果当前互斥量没有被其他线程占有,则该线程锁住互斥量,直到该线程调用unlock释放互斥量
- 如果当前互斥量被其他线程锁住,则当前调用线程返回false,而并不会被阻塞掉
- 果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。
unlock
无返回值
解锁互斥。互斥量必须为当前执行线程所锁定(以及调用lock),否则行为未定义。
example
#include <iostream>
#include <chrono> // std::chrono
#include <thread> // std::thread
#include <mutex> // std::mutex
int g_num = 0; // 为 g_num_mutex 所保护
std::mutex g_num_mutex;
void slow_increment(int id)
{
for (int i = 0; i < 3; ++i) {
g_num_mutex.lock();
++g_num;
std::cout << "th" << id << " => " << g_num << '\n';
g_num_mutex.unlock();
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
int main()
{
std::thread t1(slow_increment, 0);
std::thread t2(slow_increment, 1);
t1.join();
t2.join();
}
输出
th0 => 1
th1 => 2
th0 => 3
th1 => 4
th1 => 5
th0 => 6
std::recursive_mutex
定义
递归式互斥锁,同一个线程可以多次获得锁,而不会死锁
PS:lock
和unlock
的次数必须相等,其他线程才能获得锁
用法
成员与std::mutex
一致
#include <iostream>
#include <thread>
#include <mutex>
class X {
std::recursive_mutex m;
std::string shared;
public:
void fun1() {
m.lock();
shared = "fun1";
std::cout << "in fun1, shared variable is now " << shared << '\n';
m.unlock();
}
void fun2() {
m.lock();
shared = "fun2";
std::cout << "in fun2, shared variable is now " << shared << '\n';
fun3(); // 递归锁在此处变得有用
std::cout << "back in fun2, shared variable is " << shared << '\n';
m.unlock();
}
void fun3() {
m.lock();
shared = "fun3";
std::cout << "in fun3, shared variable is now " << shared << '\n';
m.unlock();
}
};
int main()
{
X x;
std::thread t1(&X::fun1, &x);
std::thread t2(&X::fun2, &x);
t1.join();
t2.join();
}
输出
in fun1, shared variable is now fun1
in fun2, shared variable is now fun2
in fun3, shared variable is now fun3
back in fun2, shared variable is fun3
std::time_mutex
定义
增加了带时限的try_lock
用法
try_lock_for
尝试获得锁,若无法立即得到,则最多阻塞timeout_duration
或在此期间获得锁,指的是时间段
成功=True,反之=False
example
#include <iostream>
#include <sstream>
#include <thread>
#include <chrono>
#include <vector>
#include <mutex>
std::timed_mutex mutex;
using namespace std::chrono_literals;
void do_work(int id) {
std::ostringstream stream;
for (int i = 0; i < 3; ++i) {
if (mutex.try_lock_for(100ms)) {
stream << "success ";
std::this_thread::sleep_for(100ms);
mutex.unlock();
} else {
stream << "failed ";
}
std::this_thread::sleep_for(100ms);
}
std::cout << "[" << id << "] " << stream.str() << std::endl;
}
int main() {
// try_lock_for
std::vector<std::thread> threads;
for (int i = 0; i < 4; ++i) {
threads.emplace_back(do_work, i);
}
for (auto& t : threads) {
t.join();
}
}
输出
[3] failed success failed
[0] success failed success
[2] failed failed failed
[1] success success success
try_lock_until
尝试锁互斥。直到到达指定的时间才超时,指的是时间点
成功=True,反之=False
example
#include <iostream>
#include <sstream>
#include <thread>
#include <chrono>
#include <vector>
#include <mutex>
std::timed_mutex mutex;
using namespace std::chrono;
void do_work() {
mutex.lock();
std::cout << "thread 1, sleeping..." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(4));
mutex.unlock();
}
void do_work2() {
auto now = std::chrono::steady_clock::now();
if (mutex.try_lock_until(now + 5s)) {
auto end = steady_clock::now();
std::cout << "try_lock_until success, ";
std::cout << "time use: " << duration_cast<milliseconds>(end-now).count()
<< "ms." << std::endl;
mutex.unlock();
} else {
auto end = steady_clock::now();
std::cout << "try_lock_until failed, ";
std::cout << "time use: " << duration_cast<milliseconds>(end-now).count()
<< "ms." << std::endl;
}
}
int main() {
// try_lock_until
std::thread t1(do_work);
std::thread t2(do_work2);
t1.join();
t2.join();
}
输出
thread 1, sleeping...
try_lock_until success, time use: 4000ms.
std::recursive_timed_mutex
定义
以类似std::recursive_mutex
的方式,recursive_timed_mutex
提供排他性递归锁,同线程可以重复获得锁。另外,recursive_timed_mutex
通过try_lock_for
与try_lock_until
方法,提供带时限地获得recursive_timed_mutex
锁,类似std::time_mutex
。
std::shared_mutex
定义
c++ 17 新出的具有独占模式和共享模式的锁。
std::shared_mutex
是读写锁,把对共享资源的访问者划分成读者和写者,读者只对共享资源进行读访问,写者则需要对共享资源进行写操作。
它提供两种访问权限的控制:共享性(shared)和排他性(exclusive)。通过lock/try_lock
获取排他性访问权限(仅有一个线程能占有互斥),通过lock_shared/try_lock_shared
获取共享性访问权限(多个线程能共享同一互斥的所有权)。这样的设置对于区分不同线程的读写操作特别有用。
std::shared_mutex
通常用于多个读线程能同时访问同一资源而不导致数据竞争,但只有一个写线程能访问的情形。
#include <iostream>
#include <mutex> // 对于 std::unique_lock
#include <shared_mutex>
#include <thread>
class ThreadSafeCounter {
public:
ThreadSafeCounter() = default;
// 多个线程/读者能同时读计数器的值。
unsigned int get() const {
std::shared_lock<std::shared_mutex> lock(mutex_);
return value_;
}
// 只有一个线程/写者能增加/写线程的值。
void increment() {
std::unique_lock<std::shared_mutex> lock(mutex_);
value_++;
}
// 只有一个线程/写者能重置/写线程的值。
void reset() {
std::unique_lock<std::shared_mutex> lock(mutex_);
value_ = 0;
}
private:
mutable std::shared_mutex mutex_;
unsigned int value_ = 0;
};
int main() {
ThreadSafeCounter counter;
auto increment_and_print = [&counter]() {
for (int i = 0; i < 3; i++) {
counter.increment();
std::cout << std::this_thread::get_id() << ' ' << counter.get() << '\n';
// 注意:写入 std::cout 实际上也要由另一互斥同步。省略它以保持示例简洁。
}
};
std::thread thread1(increment_and_print);
std::thread thread2(increment_and_print);
thread1.join();
thread2.join();
}
// 解释:下列输出在单核机器上生成。 thread1 开始时,它首次进入循环并调用 increment() ,
// 随后调用 get() 。然而,在它能打印返回值到 std::cout 前,调度器将 thread1 置于休眠
// 并唤醒 thread2 ,它显然有足够时间一次运行全部三个循环迭代。再回到 thread1 ,它仍在首个
// 循环迭代中,它最终打印其局部的计数器副本的值,即 1 到 std::cout ,再运行剩下二个循环。
// 多核机器上,没有线程被置于休眠,且输出更可能为递增顺序。
可能的输出
139847802500864 1
139847802500864 2
139847802500864 3
139847794108160 4
139847794108160 5
139847794108160 6
std::shared_timed_mutex
它是从C++14 才提供的限时读写锁:std::shared_timed_mutex
。
对比std::shared_mutex
新增下面两个接口,其实这两个接口与上面讲到的std::timed_mutex
的try_lock_for
和try_lock_until
类似。都是限时等待锁。只不过是增加了共享属性。
互斥锁
- mutex,用于保证在任何时刻,都只能有一个线程访问该对象。 当获取锁操作失败时,线程会进入睡眠,等待锁释放时被唤醒。
- 要么锁住、要么不锁住
读写锁
- 相较于互斥锁,读写锁允许更高的并行性
- 也称为“共享-独占锁”
- 当处于写加锁时,在其解锁之前,所有尝试加锁线程都会阻塞
- 当处于读加锁时,所有试图对其加锁的线程都可以得到访问权
- 写锁会阻塞其它读写锁。当有一个线程获得写锁在写时,读锁也不能被其它线程获取;写者优先于读者(一旦有写者,则后续读者必须等待,唤醒时优先考虑写者)。适用于读取数据的频率远远大于写数据的频率的场合。
总结
- 由于它们额外的复杂性,读/写锁
std::shared_mutex
,std::shared_timed_mutex
优于普通锁std::mutex
,std::timed_mutex
的情况比较少见。但是理论上确实存在。 - 如果在频繁但短暂的读取操作场景,读/写互斥不会提高性能。它更适合于读取操作频繁且耗时的场景。当读操作只是在内存数据结构中查找时,很可能简单的锁会胜过读/写锁。
- 如果读取操作的开销非常大,并且您可以并行处理许多操作,那么在某些时候增加读写比率应该会导致读取/写入器性能优于排他锁的情况。断点在哪里取决于实际工作量。
- 另请注意,在持有锁的同时执行耗时的操作通常是一个坏兆头。可能有更好的方法来解决问题,然后使用读/写锁。
- 还要注意,在使用mutex时,要时刻注意lock()与unlock()的加锁临界区的范围,不能太大也不能太小,太大了会导致程序运行效率低下,大小了则不能满足我们对程序的控制。并且我们在加锁之后要及时解锁,否则会造成死锁,lock()与unlock()应该是成对出现。
参考文章
C++ 多线程:互斥量(mutex)_c++ 互斥-CSDN博客
标签:std,lock,C++,互斥,mutex,线程,Mutex,include From: https://blog.csdn.net/weixin_44623642/article/details/143196952