并发支持库(3)-互斥

互斥可以对操作集合上锁，避免多个线程同时访问共享资源。这些操作集合可以看作是一次原子操作。

本文章的代码库：

https://gitee.com/gamestorm577/CppStd

1. 互斥类

c++提供了各种互斥类。

mutex

构造函数

默认构造函数构造一个处于未锁定状态的互斥

锁定

mutex提供lock和try_lock接口用于锁定互斥，unlock用于解锁互斥。

1.调用线程调用lock时，如果mutex为未锁定状态，那么调用线程锁住该互斥；如果mutex为锁定状态，那么调用线程阻塞，知道mutex被解锁。

2.调用线程调用try_lock尝试锁定mutex并立即返回。如果mutex为未锁定状态，那么try_lock返回true并锁住mutex；如果mutex为锁定状态，try_lock返回false。

3.调用线程调用unlock解锁互斥。

4.调用线程调用lock或者try_lock时必须不占有mutex，调用unlock时mutex必须被调用线程锁定，否则会出现未定义行为。

代码示例：

int num = 0;
std::mutex mutex;auto Func = [&](int id)
{for (int i = 0; i < 5; ++i){mutex.lock();++num;std::cout << id << ": " << num << std::endl;mutex.unlock();std::this_thread::sleep_for(std::chrono::milliseconds(100));}
};std::thread t1(Func, 0);
std::thread t2(Func, 1);
t1.join();
t2.join();

可能的输出结果：

native_handle

返回mutex的底层实现句柄

timed_mutex

相比mutex，timed_mutex可以实现指定时间的锁定，对应的接口为try_lock_for和try_lock_until。

recursive_mutex

对于mutex，当某个执行线程已经占用mutex的情况下不能再调用lock或者try_lock，而recursive_mutex可以去掉这个限制。注意在占用mutex的情况下，调用recursive_mutex的lock或者try_lock也是有次数限制的。

recursive_time_mutex

和recursive_mutex的功能相同，同时增加了指定时间的锁定功能。

shared_mutex

shared_mutex有两个访问级别：共享性和独占性。如果一个执行线程获取了shared_mutex的独占行，那么其他线程无法获取该锁。当没有任何线程获取shared_mutex的独占性时，多个线程可以同时获取shared_mutex的共享性。

对于一些共享资源读取远多于写入操作的场景，shared_mutex可以提高并发性能。

shared_mutex的lock、try_lock接口用于获取独占性，unlock用于解锁独占性。lock_shared、try_lock_shared接口口用于获取共享性，unlock_shared用于解锁共享性。

代码示例：

auto Timer = [](std::function<void()> func) -> void
{auto start = std::chrono::system_clock::now();func();auto end = std::chrono::system_clock::now();std::chrono::duration<double, std::milli> time = end - start;std::cout << "use time: " << time.count() << std::endl;
};struct Test1
{void Func(){m_Mut.lock();std::this_thread::sleep_for(std::chrono::milliseconds(10));m_Mut.unlock();}std::mutex m_Mut;
};struct Test2
{void Func(){m_Mut.lock_shared();std::this_thread::sleep_for(std::chrono::milliseconds(10));m_Mut.unlock_shared();}std::shared_mutex m_Mut;
};auto Func1 = []()
{Test1 test1;std::vector<std::thread> threads(20);for (auto& t : threads){t = std::thread(&Test1::Func, &test1);}for (auto& t : threads){t.join();}
};auto Func2 = []()
{Test2 test2;std::vector<std::thread> threads(20);for (auto& t : threads){t = std::thread(&Test2::Func, &test2);}for (auto& t : threads){t.join();}
};Timer(Func1);
Timer(Func2);

输出结果：

use time: 326
use time: 33.2421

shared_timed_mutex

shared_timed_mutex和shared_mutex的功能相同，并且支持指定时间的锁定

2. lock类

c++提供了一些lock类用于方便地管理互斥类

lock_guard

lock_guard提供互斥体的RAII风格的包装。当创建lock_guard对象时，它试图占有给定互斥的所有权，当lock_guard离开作用域时，lock_guard被销毁并释放互斥体。代码示例：

struct MyMutex
{void lock(){std::cout << "MyMutex lock" << std::endl;}void unlock(){std::cout << "MyMutex unlock" << std::endl;}
};MyMutex mut;
std::lock_guard<MyMutex> lock(mut);

输出结果：

MyMutex lock
MyMutex unlock

scoped_lock

scoped_guard提供多个互斥体的RAII风格的包装。代码示例：

struct MyMutex
{void lock(){std::cout << "MyMutex lock: " << Id << std::endl;}bool try_lock(){std::cout << "MyMutex try_lock: " << Id << std::endl;return true;}void unlock(){std::cout << "MyMutex unlock: " << Id << std::endl;}int Id = 0;
};MyMutex mut1;
MyMutex mut2;
MyMutex mut3;
mut1.Id = 3;
mut2.Id = 17;
mut3.Id = 29;std::scoped_lock lock(mut1, mut2, mut3);

输出结果：

MyMutex lock: 3
MyMutex try_lock: 17
MyMutex try_lock: 29
MyMutex unlock: 3
MyMutex unlock: 17
MyMutex unlock: 29

unique_lock

unique_lock是一个通用的互斥包装器。

shared_lock

shared_lock是一个通用的共享互斥包装器。

3. 通用锁定算法

c++提供了std::try_lock、std::lock用于锁定互斥

4. 单次调用

c++提供了接口std::call_once来确保函数只被调用一次，无论是单线程还是多线程。代码示例：

struct Test
{void Func(){std::cout << "call Func: " << Id << std::endl;}void CallFuncOnce(){std::call_once(flag, &Test::Func, this);}std::once_flag flag;int Id = 0;
};Test test1;
Test test2;
test1.Id = 3;
test2.Id = 17;test1.CallFuncOnce();
test1.CallFuncOnce();
test1.CallFuncOnce();
test1.CallFuncOnce();std::jthread t1(&Test::CallFuncOnce, &test2);
std::jthread t2(&Test::CallFuncOnce, &test2);
std::jthread t3(&Test::CallFuncOnce, &test2);

输出结果：