标签：std include resource lock C++ 互斥 mutex 程间多线程

第三章在线程间共享数据

共享数据基本问题

如果所有共享数据都只读,那就没有问题.

不变量(invariants): 对特定数据结构总为真的语句.例如:"该变量表示线程数量."

修改线程之间共享数据的一个常见潜在问题就是破坏不变量.

竞争条件(race condition): 线程竞争执行各自的操作,导致不变量的破坏.

数据竞争(data race): 因对当个对象的并发修改而产生的特定类型的竞争条件.

软件事务内存(STM): 所需的一系列数据修改和读取被存储在一个事务日志中,然后在单个步骤中提交.如果该提交因为数据结构已被另一个线程修改而无法进行,该事务将重新启动.

使用互斥元

互斥元(mutex): 在访问共享数据结构之前,锁定(lock) 该数据相关互斥元;当访问数据结构完成后, 解锁(unlock) 该互斥元.线程库会保证一旦某个线程锁定了某个互斥元,所有试图锁定相同互斥元的其他线程都需要等待.

创建互斥元:

std::mutex some_mutex;

锁定互斥元:

some_mutex.lock();

解锁互斥元:

some_mutex.unlock();

使用RAII惯用语法的互斥元:

std::lock_guard<std::mutex>guard(some_mutex);

为了解释互斥元的使用,在这里使用一个简单的例子对其进行解释:

#include <iostream>
#include <thread>
#include <windows.h>

int count = 0;

void func_1()
{
	for (int i = 0; i < 10000; i++)
		count++;
	return;
}

void func_2()
{
	for (int i = 0; i < 10000; i++)
		count++;
	return;
}

int main()
{
	std::thread t_1(func_1);
	std::thread t_2(func_2);
	t_1.join();
	t_2.join();

	for (int i = 0; i < 10000; i++)
		count++;
	std::cout << "the value of count is :" << count;

	return 0;
}

由于对全局变量count的抢用,事实上,这个程序最终得到的结果是随机的.

然而,通过对std::mutex的使用,我们可以尽可能避免这一问题:

#include <iostream>
#include <thread>
#include <mutex>
#include <windows.h>

int count = 0;
std::mutex count_mutex;

void func_1()
{
	std::lock_guard<std::mutex>guard(count_mutex);
	for (int i = 0; i < 10000; i++)
		count++;
	return;
}

void func_2()
{
	std::lock_guard<std::mutex>guard(count_mutex);
	for (int i = 0; i < 10000; i++)
		count++;
	return;
}

int main()
{
	std::thread t_1(func_1);
	std::thread t_2(func_2);
	t_1.join();
	t_2.join();

	for (int i = 0; i < 10000; i++)
		count++;
	std::cout << "the value of count is :" << count;

	return 0;
}

在上面的代码中,我们首先创建了一个全局std::mutex互斥量.

然后,在使用的过程中,我们使用RAII惯用语法std::lock_guard来对其进行管理,保证了过程的完整性.

保护并行数据

由于并行常常带来一些意想不到的问题,所以我们需要思考如何更好地保护并行程序中的数据,下面是一个有趣的例子:

#include <iostream>
#include <thread>
#include <mutex>
#include <format>

std::mutex func_mutex;

template<typename Function>
void doSomething(Function func)
{
	std::lock_guard<std::mutex>guard(func_mutex);
	int data = 100;
	func(data);

	std::cout << std::format("the data is: {}", data);
	return;
}

void badFunc(int& data)
{
	data = 200;
	return;
}


int main()
{
	std::thread t(&doSomething<void(int&)>, badFunc);
	t.join();
	std::lock_guard<std::mutex>guard(func_mutex);

	return 0;
}

在上面的例子中,我们设计了一个函数doSomething,其接收外部的函数来对数据进行操作.

然而,我们模拟了一个恶意函数badFunc传入的情景: 它通过引用绕开了锁并修改了数据!

这在大多数情况下当然不是我们想要的.

因而记住: 不要将指向受保护数据的指针与引用传递到锁的范围之外.

死锁

死锁(deadlock): 一对线程中的每一个都需要同时锁定两个互斥元来执行一些操作,并且每个线程都拥有了一个互斥元,同时等待另外一个.两个线程都无法继续.

下面是一个死锁的例子:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mutex_1;
std::mutex mutex_2;

void func_1()
{
	for (int i = 0; i < 10; i++) {
		std::cout << "now is func_1" << std::endl;
		std::lock_guard<std::mutex>guard_1(mutex_1);
		std::lock_guard<std::mutex>guard_2(mutex_2);
	}
	std::cout << "func_1" << std::endl;
	return;
}
void func_2()
{
	for (int i = 0; i < 10; i++) {
		std::cout << "now is func_2" << std::endl;
		std::lock_guard<std::mutex>guard_2(mutex_2);
		std::lock_guard<std::mutex>guard_1(mutex_1);
	}
	std::cout << "func_2" << std::endl;
	return;
}

int main()
{
	std::thread t_1(func_1);
	std::thread t_2(func_2);
	t_1.join();
	t_2.join();

	return 0;
}

为了避免死锁,常见的建议是始终使用相同的顺序锁定这两个互斥元.这在大多数情况有效.

但是,实际上,有一种更为方便的方法: 通过std::lock同时锁定两个或更多互斥元.

同时锁定多个互斥元:

std::lock(mutex_1,mutex_2[,other...]);

将已锁定的互斥元的所有权转移到lock_guard:

std::lock_guard<std::mutex>guard(mutex_1,std::adopt_lock);

我们利用std::lock,解决上面的死锁问题:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mutex_1;
std::mutex mutex_2;

void func_1()
{
	for (int i = 0; i < 10; i++) {
		std::lock(mutex_1, mutex_2);
		std::cout << "now is func_1" << std::endl;
		std::lock_guard<std::mutex>guard_1(mutex_1,std::adopt_lock);
		std::lock_guard<std::mutex>guard_2(mutex_2,std::adopt_lock);
	}
	std::cout << "func_1" << std::endl;
	return;
}
void func_2()
{
	for (int i = 0; i < 10; i++) {
		std::lock(mutex_2, mutex_1);
		std::cout << "now is func_2" << std::endl;
		std::lock_guard<std::mutex>guard_2(mutex_2,std::adopt_lock);
		std::lock_guard<std::mutex>guard_1(mutex_1,std::adopt_lock);
	}
	std::cout << "func_2" << std::endl;
	return;
}

int main()
{
	std::thread t_1(func_1);
	std::thread t_2(func_2);
	t_1.join();
	t_2.join();

	return 0;
}

然而,死锁的来源远不止锁定.例如下面这个例子:

#include <iostream>
#include <thread>

void func(std::thread& t)
{
	t.join();
	return;
}

int main()
{
	std::thread t1, t2;

	std::thread temp_1(func, std::ref(t2));
	t1 = std::move(temp_1);
	std::thread temp_2(func, std::ref(t1));
	t2 = std::move(temp_2);

	t1.join();

	return 0;
}

其通过两个线程之间的互相调用实现了死锁.

上面的例子为我们说明了死锁现象的防不胜防.为了尽量避免死锁的出现,我们有下面几点建议:

避免嵌套锁:如果你已经持有一个锁,就别再获取锁.
在持有锁时,避免调用用户提供的代码.
以固定顺序获取锁:在每个线程中以相同顺序获得锁.
使用锁层次:

锁层次通过对线程当前层次值,上一次层次值的保存,结合锁层次值,在不符合锁层次时抛出logic_error来解决死锁.

hierarchical_mutex:

class hierarchical_mutex
{
private:
	std::mutex internal_mutex;
	unsigned long const hierarchy_value;
	unsigned long previous_hierarchy_value;
	static thread_local unsigned long this_thread_hierarchy_value;
	void checkForHierarchyViolation()
	{
		if (this_thread_hierarchy_value <= hierarchy_value)
			throw std::logic_error("mutex hierarchy violated");
	}
	void updateHierarchyValue()
	{
		previous_hierarchy_value = this_thread_hierarchy_value;
		this_thread_hierarchy_value = hierarchy_value;
	}
public:
	explicit hierarchical_mutex(unsigned long value)
		:hierarchy_value(value), previous_hierarchy_value(0){ return; }
	void lock()
	{
		checkForHierarchyViolation();
		internal_mutex.lock();
		updateHierarchyValue();
	}
	void unlock()
	{
		this_thread_hierarchy_value = previous_hierarchy_value;
		internal_mutex.unlock();
	}
	bool try_lock()
	{
		checkForHierarchyViolation();
		if (!internal_mutex.try_lock())
			return false;
		updateHierarchyValue();
		return true;
	}
};
thread_local unsigned long hierarchical_mutex::this_thread_hierarchy_value(ULONG_MAX);

下面再给出一个使用锁层次的实例:

#include <iostream>
#include <thread>
#include <mutex>

hierarchical_mutex mutex_1(1000);
hierarchical_mutex mutex_2(500);

void func_1()
{
	try {
		for (int i = 0; i < 10; i++) {
			std::cout << "now is func_1" << std::endl;
			std::lock_guard<hierarchical_mutex>guard_1(mutex_1);
			std::lock_guard<hierarchical_mutex>guard_2(mutex_2);
		}
	}
	catch (std::logic_error) {
		std::cout << "func_1" << std::endl;
	}
	return;
}
void func_2()
{
	try {
		for (int i = 0; i < 10; i++) {
			std::cout << "now is func_2" << std::endl;
			std::lock_guard<hierarchical_mutex>guard_2(mutex_2);
			std::lock_guard<hierarchical_mutex>guard_1(mutex_1);
		}
	}
	catch (std::logic_error) {
		std::cout << "func_2" << std::endl;
	}
	return;
}

int main()
{
	std::thread t_1(func_1);
	std::thread t_2(func_2);
	t_1.join();
	t_2.join();

	return 0;
}

由于func_2处存在不符合的层次值的情况,因而该线程的循环很快终止.也避免了死锁.

灵活锁定

通过松弛不变量,std::unique_lock比std::lock_guard提供了更多的灵活性,一个std::unique_lock实例不总是拥有与之相关联的互斥元.

使用std::unique_lock与std::defer_lock相结合,可以很方便地实现std::lock_guard与std::adopt_lock相结合的效果.

std::adopt_lock表示互斥元已被锁上,std::defer_lock则表示互斥元暂未被锁上.

将未被锁定的互斥元记录到unique_lock:

std::unique_lock<std::mutex> ulock(mutex_1,std::defer_lock);

下面是通过其解决死锁问题的方式:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mutex_1;
std::mutex mutex_2;

void func_1()
{
	for (int i = 0; i < 10; i++) {
		std::unique_lock<std::mutex>ulock_1(mutex_1, std::defer_lock);
		std::unique_lock<std::mutex>ulock_2(mutex_2, std::defer_lock);
		std::lock(mutex_1, mutex_2);
		std::cout << "now is func_1" << std::endl;
	}
	std::cout << "func_1" << std::endl;
	return;
}
void func_2()
{
	for (int i = 0; i < 10; i++) {
		std::unique_lock<std::mutex>ulock_2(mutex_2, std::defer_lock);
		std::unique_lock<std::mutex>ulock_1(mutex_1, std::defer_lock);
		std::lock(mutex_2, mutex_1);
		std::cout << "now is func_2" << std::endl;
	}
	std::cout << "func_2" << std::endl;
	return;
}

int main()
{
	std::thread t_1(func_1);
	std::thread t_2(func_2);
	t_1.join();
	t_2.join();

	return 0;
}

因为std::unique_lock实例并没有拥有与其相关的互斥元,所以通过四处移动(moving)实例,互斥元的所有权可以在实例之间进行转移.

单一全局实例

设想一个 延迟初始化(lazy initialization) 的例子.这在单线程代码中很常见:每个请求资源的操作首先检查它是否已经初始化,如果没有就在使用之前初始化.

std::shared_ptr<some_resource> resource_ptr;
void foo()
{
	if(!resource_ptr)
		resource_ptr.reset(new some_resource);
	resource_ptr->do_something();
	return;
}

一般来说,在其中使用互斥元的做法为:

std::shared_ptr<some_resource>resource_ptr;
std::mutex resource_mutex;
void foo()
{
	std::unique_lock<std::mutex>lk(resource_mutex);
	if(!resource_ptr)
		resource_ptr.reset(new some_resource);
	lk.unlock();
	resource_ptr->do_something();
	return;
}

然而,这样会有很大的非必要序列化问题.

于是,有人提出了臭名昭著的 二次检查锁定(double-checked locking) 模式.

这一模式已被证明是灾难性的.

void double_checked_locking()
{
	if(!resource_ptr){
		std::lock_guard<std::mutex>lk(resource_mutex);
		if(!resource_ptr)
			resource_ptr.reset(new some_resource);
	}
	resource_ptr->do_something();
	return;
}

由于在线程对指针所指向内存进行修改时可能尚未flush,这可能导致数据竞争的问题,新的数据被更新的数据覆盖.

为了解决上面情景的问题,C++提供了 std::call_once 与 std::once_flag 来处理这种情景.

使用std::call_once可以使得某函数只被一个线程执行,且效率比std::mutex高.

我们通过下面这个例子来说明:

#include <iostream>
#include <format>
#include <thread>
#include <mutex>
#include <omp.h>

std::shared_ptr<double>resource_ptr_1;
std::shared_ptr<double>resource_ptr_2;
std::mutex resource_mutex;
std::once_flag resource_flag;
void init_resource()
{
	resource_ptr_2.reset(new double);
	return;
}
void foo_1()
{
	std::unique_lock<std::mutex>lk(resource_mutex);
	if (!resource_ptr_1)
		resource_ptr_1.reset(new double);
	lk.unlock();
	return;
}
void foo_2()
{
	std::call_once(resource_flag, init_resource);
	return;
}
int main()
{
	double temp_time, run_time;
	
	temp_time = omp_get_wtime();
	std::thread t1(foo_1);
	std::thread t2(foo_1);
	t1.join(), t2.join();
	run_time = omp_get_wtime() - temp_time;

	std::cout << std::format("the runtime_1 is {:.15f}s", 
		run_time
	) << std::endl;;

	temp_time = omp_get_wtime();
	std::thread t3(foo_2);
	std::thread t4(foo_2);
	t3.join(), t4.join();
	run_time = omp_get_wtime() - temp_time;

	std::cout << std::format("the runtime_2 is {:.15f}s",
		run_time
	) << std::endl;;

	return 0;
}

其运行结果为:

the runtime_1 is 0.004862599889748s
the runtime_2 is 0.000809999997728s

在C++中,如果需要单一全局实例,那么还可以通过static变量来实现.

在C++11之前,对static变量的初始化可能造成数据竞争.但是现在static可以用作std::call_once的替代品.

读写互斥元

读写互斥元(reader-writer): 由单个"写"线程独占访问或共享,由多个"读"线程并发访问.

C++标准库目前没有直接提供这样的互斥元,但是boost库提供了.

创建一个共享锁

mutable boost::shared_mutex entry_mutex;

锁定一个共享锁

std::lock_guard<boost::shared_mutex> guard(entry_mutex);

共享锁定一个共享锁

boost::shared_lock<boost::shared_mutex>lk(entry_mutex);

独占锁定一个共享锁

std::unique_lock<boost::shared_mutex>lk(entry_mutex);

如果一个线程拥有一个共享锁,试图获取独占锁的线程会被阻塞,知道其他线程全部撤回他们的锁.

如果一个线程拥有独占锁,其他线程都不能获取共享锁或独占锁.

共享锁可以用于许多情景,其中一个与我们最贴切的情景就是通过并行串口COM进行串口通信时数据的读写.

递归锁

在前面第二章我们提到过,对同一个std::mutex进行多次锁定是一个 未定义行为(undefined behavior).

所以是否存在一个可以多次锁定的互斥元呢?答案是:是的,那就是递归锁.

创建一个递归锁

std::recursive_mutex some_mutex;

这个互斥元是可以锁定多次的.但是,相对的,当你多次lock后,你也需要多次unlock才能解除对其的锁定.

在开发中使用递归锁是不推荐的.

标签：std,include,resource,lock,C++,互斥,mutex,程间,多线程
From： https://www.cnblogs.com/mesonoxian/p/18006483

C++多线程第三章在线程间共享数据

第三章在线程间共享数据

共享数据基本问题

使用互斥元

保护并行数据

死锁

灵活锁定

单一全局实例

读写互斥元

递归锁

相关文章

赞助商

阅读排行

C++多线程 第三章 在线程间共享数据

第三章 在线程间共享数据

共享数据基本问题

使用互斥元

保护并行数据

死锁

灵活锁定

单一全局实例

读写互斥元

递归锁

相关文章

赞助商

阅读排行

C++多线程第三章在线程间共享数据

第三章在线程间共享数据