《c++并发编程实战》之第3章 线程共享
《c++并发教程实战》之第3章 线程共享
-
- 3.1 共享问题
-
- 3.1.1 条件竞争
- 3.1.2 防止恶性条件竞争
- 3.2 互斥保护共享数据
-
- 3.2.1 使用互斥
-
- 3.1.cpp
- 3.2.2 组织和编排代码保护共享数据
-
- 3.2.cpp
- 3.2.3 接口固有的条件竞争
-
- 3.3.cpp
- 3.4.cpp
- 3.5.cpp
- 3.2.4 死锁问题和解决方法
-
- 3.6.cpp
- 3.2.5 防范死锁的补充原则
-
- 3.7.cpp
- 3.8.cpp
- 3.2.6 std::unique_lock<>灵活加锁
-
- 3.9.cpp
- 3.2.7 不同作用域间转移互斥归属权
- 3.2.8 按合适粒度加锁
-
- 3.10.cpp
- 3.3 其它工具保护共享数据
-
- 3.3.1 初始化过程中保护共享数据
-
- 3.11.cpp
- 3.12.cpp
- 3.3.2 保护甚少更新的数据结构（读写锁）
-
- 3.13.cpp
- 3.3.3 递归加锁
3.1 共享问题
只读数据无问题。数据改动可能引发问题。
3.1.1 条件竞争
线程执行各自操作的结果取决于执行的相对次序。
3.1.2 防止恶性条件竞争
-
锁
采取保护措施包装数据结构，确保不变量被破坏时，中间状态只对执行改动的线程可见。 -
无锁
修改数据结构的设计及其不变量，由一连串不开拆分的改动完成数据变更，每个改动都维持不变量不被破坏。 -
修改数据结构当作事务（transaction，类似数据库，本书不考虑）处理。
3.2 互斥保护共享数据
访问数据结构钱，锁住互斥；访问结束后，解锁互斥。
3.2.1 使用互斥
3.1.cpp
#include
#include 3.2.2 组织和编排代码保护共享数据
不得向锁所在的作用域之外传递指针和引用，指向受保护的共享数据，无论是通过函数返回值将它们保存到对外可见的内存，还是将它们作为参数传递给使用者提供的函数。
3.2.cpp
#include 3.2.3 接口固有的条件竞争
3.3.cpp
#include stact<int> s;
if(!s.empty()) { //1
int const value = s.top(); //2
s.pop(); //3
do_something(value);
}
多线程情况下，1，2，3之间交替运行会出错。
消除条件竞争的方法：
- 传入引用
std::vector<int> result;
some_stack.pop(result);
短处：构造result需要代价，栈容器存储类别要可赋值。
-
提供不抛出异常的拷贝构造函数或移动构造函数
-
返回指针，指向弹出的元素
指针可自由的复制，建议使用std::shared_ptr。
- 结合方法1和方法2，或结合方法1和方法3
template <typename T>
class stack {
public:
bool pop(T &t) {
lock_guard<mutex> l(m);
if(data.empty())
return false;
t = std::move(data.top()); //T需要移动构造函数
data.pop();
return true;
}
private:
deque<T> data;
mutex m;
}
- 线程安全的栈容器类
简要定义
3.4.cpp
#include 详尽定义
3.5.cpp
#include 3.2.4 死锁问题和解决方法
为了某项操作而对多个互斥加锁，都锁住一个互斥，等着给另一个互斥加锁，双方苦等对方解锁互斥，形成死锁。
常见解决方法，始终按相同顺序对两个互斥加锁；同时锁住多个互斥。
3.6.cpp
#include guard(lhs.m, rhs.m);
swap(lhs.some_detail, rhs.some_detail);
}
};
int main()
{
return 0;
}
3.2.5 防范死锁的补充原则
只要另一线程有可能正在等待当前线程，那么当前线程千万不能反过来等待它。
- 避免嵌套锁
已持有锁，则不用试图获取第二个锁（每个线程最多一个锁）。需获取多个锁，调用std::lock()函数，一次同时获取全部锁。
- 持锁后，避免调用用户接口
用户程序接口可能随意操作，包括试图获取锁。
-
固定顺序获取锁
-
按层级加锁
3.7.cpp
#include 3.8.cpp
#include - 将准则推广到操作以外
死锁现象并不单单因加锁操作而发生，任何同步机制导致的循环等待都会导致死锁出现。
3.2.6 std::unique_lock<>灵活加锁
可完全替代std::lock_guard(优先使用lock_guard)，有性能损失。
mutex mtx;
mtx.lock();
//std::adopt_lock表明mtx已调用lock()，lock构造函数不再调用lock()
std::unique_lock<std::mutex> lock(mtx, std::adopt_lock);
mutex mtx;
//std::defer_lock表明lock构造函数不调用lock()，后面会调用
std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
3.9.cpp
#include 3.2.7 不同作用域间转移互斥归属权
互斥归属权可在多个std::unique_lock实例间转移。
std::unique_lock<std::mutex> get_lock(){
extern std::mutex some_mutex:
std::unique_lock<std::mutex> lk(some_mutex);
prepare_data();
return lk;
}
void process_data(){
std::unique_lock<std::mutex> lk(get_lock());
do_something();
}
3.2.8 按合适粒度加锁
仅仅在访问共享数据期间才锁住互斥，让数据处理尽可能不用锁保护。
持锁期间，避免耗时操作，如读写文件。
void get_and_process_data(){
std::unique_lock<std::mutex> my_lock(the_mutex);
some_class data_to_process = get_next_data_chunk();
my_lock.unlock();
result_type result = process(data_to_process);
my_lock.lock();
write_result(data_to_process, result);
}
3.10.cpp
#include 3.3 其它工具保护共享数据
共享数据仅初始化（创建）过程中受到保护，之后无需保护（只读）。
3.3.1 初始化过程中保护共享数据
创建共享数据开销不菲（建立数据库连接、分配大量内存等），等到必要时（使用）才创建，延迟初始化（lazy initialization），常见于单线程。
std::shared_ptr<some_resource> resource_ptr;
void foo() {
if(!resource_ptr){
resource_ptr.reset(new some_resource());
}
resource_ptr->do_something();
}
互斥实现线程安全的延迟初始化
3.11.cpp
#include std::shared_ptr<some_resource> resource_ptr;
std::once_flag resource_flag;
void init_resource(){
resource_ptr.reset(new some_resource);
}
void foo(){
std::call_once(resource_flag, init_resource);
resource_ptr->do_something();
}
once_flag和call_once实现延迟初始化
3.12.cpp
#include 代替std::call_once()
class my_class{
};
my_class& get_my_class_instance(){
static my_class instance;
return instance;
}
3.3.2 保护甚少更新的数据结构（读写锁）
C++11无，C++14增加std::shared_timed_mutex，C++17增加std::shared_mutex。
读锁（共享锁）std::shared_lockstd::shared_mutex
写锁（排他锁）std::lock_guardstd::shared_mutex和std::unique_guardstd::shared_mutex
3.13.cpp
#include
#include 3.3.3 递归加锁
互斥的同一实例多次加锁，一般是设计需要修改。
std::lock_guard<std::recursive_mutex>