#include <thread>
#include <set>
#include <random>

using namespace std;

int main()
{
	std::set<int> int_set;
	auto f = [&int_set](){
		try
		{
			std::random_device rd;
			std::mt19937 gen(rd());
			std::uniform_int_distribution<> dis(1, 1000);
			for (std::size_t i = 0; i != 100000; ++i)
			{
				int_set.insert(dis(gen));
				cout << dis(gen) << endl;
			}
		}
		catch (...)
		{

		}
	};

	std::thread td1(f), td2(f);
	td1.join();
	td2.join();

	getchar();
	return 0;
}
 

#include <thread>
#include <set>
#include <random>
#include <mutex>

using namespace std;

int main()
{
	std::mutex mt;
	std::set<int> int_set;
	auto f = [&int_set, &mt](){
		try
		{
			std::random_device rd;
			std::mt19937 gen(rd());
			std::uniform_int_distribution<> dis(1, 1000);
			for (std::size_t i = 0; i != 100000; ++i)
			{
				mt.lock();
				int_set.insert(dis(gen));
				mt.unlock();
				cout << dis(gen) << endl;
			}
		}
		catch (...)
		{

		}
	};

	std::thread td1(f), td2(f);
	td1.join();
	td2.join();

	getchar();
	return 0;
}
 

互斥物件管理類模板的加鎖策略

前面提到std::lock_guard、std::unique_lock和std::shared_lock類模板在構造時是否加鎖是可選的，C++11提供了3種加鎖策略。

下表列出了互斥物件管理類模板對各策略的支援情況。

下面的程式碼中std::unique_lock指定了std::defer_lock。

1
2
3
4
5

std::mutex mt;
std::unique_lock<std::mutex> lck(mt, std::defer_lock);
assert(lck.owns_lock() == false);
lck.lock();
assert(lck.owns_lock() == true);

對多個互斥物件加鎖

在某些情況下我們可能需要對多個互斥物件進行加鎖，考慮下面的程式碼

1
2
3
4
5
6
7
8
9
10
11
12
13

std::mutex mt1, mt2;
// thread 1
{
    std::lock_guard<std::mutex> lck1(mt1);
    std::lock_guard<std::mutex> lck2(mt2);
    // do something
}
// thread 2
{
    std::lock_guard<std::mutex> lck2(mt2);
    std::lock_guard<std::mutex> lck1(mt1);
    // do something
}

如果執行緒1執行到第5行的時候恰好執行緒2執行到第11行。那麼就會出現

• 執行緒1持有mt1並等待mt2
• 執行緒2持有mt2並等待mt1

發生死鎖。
為了避免發生這類死鎖，對於任意兩個互斥物件，在多個執行緒中進行加鎖時應保證其先後順序是一致。前面的程式碼應修改成

1
2
3
4
5
6
7
8
9
10
11
12
13

std::mutex mt1, mt2;
// thread 1
{
    std::lock_guard<std::mutex> lck1(mt1);
    std::lock_guard<std::mutex> lck2(mt2);
    // do something
}
// thread 2
{
    std::lock_guard<std::mutex> lck1(mt1);
    std::lock_guard<std::mutex> lck2(mt2);
    // do something
}

更好的做法是使用標準庫中的std::lock和std::try_lock函式來對多個Lockable物件加鎖。std::lock(或std::try_lock)會使用一種避免死鎖的演算法對多個待加鎖物件進行lock操作(std::try_lock進行try_lock操作)，當待加鎖的物件中有不可用物件時std::lock會阻塞當前執行緒知道所有物件都可用(std::try_lock不會阻塞執行緒當有物件不可用時會釋放已經加鎖的其他物件並立即返回)。使用std::lock改寫前面的程式碼，這裡刻意讓第6行和第13行的引數順序不同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

std::mutex mt1, mt2;
// thread 1
{
    std::unique_lock<std::mutex> lck1(mt1, std::defer_lock);
    std::unique_lock<std::mutex> lck2(mt2, std::defer_lock);
    std::lock(lck1, lck2);
    // do something
}
// thread 2
{
    std::unique_lock<std::mutex> lck1(mt1, std::defer_lock);
    std::unique_lock<std::mutex> lck2(mt2, std::defer_lock);
    std::lock(lck2, lck1);
    // do something
}

此外std::lock和std::try_lock還是異常安全的函式(要求待加鎖的物件unlock操作不允許丟擲異常)，當對多個物件加鎖時，其中如果有某個物件在lock或try_lock時丟擲異常，std::lock或std::try_lock會捕獲這個異常並將之前已經加鎖的物件逐個執行unlock操作，然後重新丟擲這個異常(異常中立)。並且std::lock_guard的建構函式lock_guard(mutex_type& m, std::adopt_lock_t t)也不會丟擲異常。所以std::lock像下面這麼用也是正確

1
2
3

std::lock(mt1, mt2);
std::lock_guard<std::mutex> lck1(mt1, std::adopt_lock);
std::lock_guard<std::mutex> lck2(mt2, std::adopt_lock);