C++标准线程库之共享资源
多线程下难免会需要资源共享，这样难免会发生异常情况。
#include 
编译运行这个例子可以发现有时代码正常运行输出，而有时却发生了段错误。原因在于指针_p被两个线程共享，会有三种情况：
- t1 线程已执行过访问_p，t2线程还未执行delete _p，那么就正常输出value: 77
- t1线程执行完判断还未访问_p就被挂起，t2线程调度成功执行完delete _p，然后t2线程也被挂起，t1线程唤醒继续执行访问 _p造成段错误
- t2线程执行完了_p = nullptr，t1线程判断 _p，那么就没输出，不过概率不高
- 还要种情况就留给读者自己思考了，概率也不是很高，主要还是知道会发生异常就行了
所以需要一种方法使得t1线程访问_p时，t2线程不得对 _p就行操作；同理，t2操作时，t1不得读取。
1. 使用互斥量
C++11 提供了互斥量来保护共享数据，思路是线程A在操作共享数据前上锁互斥量，其他线程执行到上锁的互斥量时就会进入阻塞，只有线程A解锁互斥量时， 其他某个线程才能继续上锁，然后那个线程继续执行后续代码。
#include #include 修复后的类X，在运行就没段错误了，保证了只有同时只有一个线程来操作_p，其他线程必须等待那个线程操作完后才能继续操作。
需要注意的是，本例子的效率来说多线程比单线程还低，这是因为包含了整个函数，没有代码处于临界区之外，也就是没有一条并行的代码。因此，mutex包含的代码区域越小越好。
2. 更加智能的锁
每次都要上锁解锁太烦了，C++11，14和17陆续加入了一些智能的锁。
2.1 最简单的自动锁lock_guard
这个锁是在构造函数中帮我们上锁，析构函数解锁，无其他额外的方法，功能简单实用，缺点是不够灵活，想解锁时只能等它销毁才能解锁。
#include class X
{
int* _p;
std::mutex mutex;
public:
X(int* p = nullptr) : _p(p) {}
~X() { if(_p) delete _p; }
void read()
{
// 小技巧, 使用代码块，避免锁的范围大到整个函数, 出代码块时锁就会销毁
{
std::lock_guard<std::mutex> lock(mutex);
if(_p) std::cout << "value: " << *_p << std::endl;
}
}
void reset()
{
{
std::lock_guard<std::mutex> lock(mutex);
if(_p) {
delete _p;
_p = nullptr;
}
}
}
};
2.2 灵活的锁unique_lock
为了解决上个锁的缺点于是诞生了灵活的锁，同样的在构造函数中上锁，但是其提供了一些方法来保证其灵活性，代价就是空间的增大。这个锁是可移动不可复制的。
#include // 省去一段无改动的代码
void read()
{
std::unique_lock<std::mutex> lock(mutex);
if(_p) std::cout << "value: " << *_p << std::endl;
}
void reset()
{
std::unique_lock<std::mutex> lock(mutex);
if(_p) {
delete _p;
_p = nullptr;
}
}
3. 死锁问题
引入了线程互斥量后，成功解决了共享资源的问题，但是互斥量不是银弹，带来了新的问题。看下面的代码：
std::mutex mutex_1, mutex_2;
void do_something_1()
{
mutex_1.lock(); // 1
mutex_2.lock(); // 2
// ...
mutex_2.unlock();
mutex_1.unlock();
}
void do_something_2()
{
mutex_2.lock(); // 3
mutex_1.lock(); // 4
// ...
mutex_1.unlock();
mutex_2.unlock();
}
两个任务由两个线程来分担，当线程A执行完1时mutex_1被上锁，线程B这是也执行过了3了mutex_2也被上锁，线程A执行2处代码发现已经上锁只能进入阻塞状态等待解锁，而线程B执行4处代码发现也是上锁的也进入阻塞状态等待解锁，就这样两个线程全在等待解锁，而又无法解锁，这样就称为线程死锁。
3.1 死锁的条件
过于理论，这里就简单提一下，不是系列的关注点
-
互斥条件
-
请求和保持条件
-
不剥夺条件
-
环路等待条件
操作系统原理都会谈到，有兴趣可以自己去学下
3.2 解决方法
C++11提供了一种方法，C++17专门提供了防死锁的智能锁来避免这个问题。
#include (1) 配合智能锁使用
// 这里需要先介绍下lock_gaurd和unique_lock都有的一个构造函数
lock_guard(mutex_type& __m, adopt_lock_t);
unique_lock(mutex_type& __m, adopt_lock_t);
// 第一个参数都是互斥量，不用介绍了，主要介绍一下第二个参数adopt_lock_t
// 这是一个指定锁定策略，有一下几个常量值
// std::defer_lock 对传入的互斥量不上锁
// std::try_to_lock 尝试对互斥量上锁
// std::adopt_lock 假设互斥量已经上锁
// 这里我也有点搞不明白，哪位大佬详细谈下这几个的区别，感觉都差不多
std::mutex mutex_1, mutex_2;
// lock_guard写法
void do_something_1()
{
std::lock(mutex_1, mutex_2);
std::lock_guard<std::mutex> lock(mutex_1, std::adopt_lock);
std::lock_guard<std::mutex> lock(mutex_2, std::adopt_lock);
// ...
}
// unique_lock写法
void do_something_2()
{
std::unique_lock<std::mutex> lock(mutex_1, std::defer_lock);
std::unique_lock<std::mutex> lock(mutex_2, std::defer_lock);
std::lock(mutex_1, mutex_2);
// ...
}
两种都可以避免死锁的发生，主要看需求选择合适的写法
(2) C++17的专门的智能锁
#include void do_something()
{
// 就一行搞定问题
std::scoped_lock lock(mutex_1, mutex_2);
// ...
}
4. 共享互斥量
有时有这样的需求：
- 当data被线程A读取时，其他线程仍可继续读取却不能写入
- 当data被线程A写入时，其他线程不可读取
这也就是读写锁
#include class dns_cache
{
std::map<std::string, dns_entry> entries;
mutable std::shared_mutex mutex;
public:
dns_entry find_entry(const std::string& domain) const
{
// 可以被多个线程读取DNS信息
std::shared_lock<std::shared_mutex> lk(mutex);
const std::map<std::string, dns_entry>::const_iterator it = entries.find(domain);
return (it == entries.end()) ? dns_entry() : it->second;
}
void update_or_add_entry(const std::string& domain, const dns_entry& dns_tetails)
{
// 更新时不可读
std::lock_guard<std::shared_mutex> lk(mutex);
entries[domain] = dns_tetails;
}
};
- 当有线程在查找dns信息时，其他线程也可以查找，但是更新线程却会阻塞，只有无线程读取时，更新线程才会解除阻塞
- 当线程更新时，其他线程无法读取
5. 特殊的互斥量
5.1 可多次上锁的互斥量
#include 5.2 定时互斥量
#include 5.3 递归定时互斥量
#include 5.4 共享定时互斥量
#include 6. 相关系列
- C++标准线程库之入门
- C++标准线程库之当前线程管理