這篇文章主要介紹了使用C++庫實現(xiàn)兩個線程交替打印，一個線程打印奇數(shù)、一個線程打印偶數(shù)，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

C++線程庫，點擊此處查看文檔

首先簡單搭一個框架，讓兩個線程先嘗試實現(xiàn)交替打印。

//實現(xiàn)兩個線程交替打印
#include <iostream>
#include <thread>
using namespace std;
int main(void)
{
	int n = 100;
	int i = 0;
	//創(chuàng)建兩個線程
	thread t1([&n, &i](){
		while (i < n)
		{
			cout << i << " ";
			i++;
		}
	});
	thread t2([&n, &i]() {
		while (i < n)
		{
			cout << i << " ";
			i++;
		}
	});
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

為了讓我們更加清楚是哪個線程打印了，我們需要獲取線程的ID。

#include <iostream>
#include <thread>
using namespace std;
int main(void)
{
	int n = 100;
	int i = 0;
	//創(chuàng)建兩個線程
	thread t1([&n, &i](){
		while (i < n)
		{
			cout << this_thread::get_id()  << ": " << i << endl;
			i++;
		}
	});
	thread t2([&n, &i]() {
		while (i < n)
		{
			cout << this_thread::get_id() << ": " << i << endl;
			i++;
		}
	});
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

這顯然沒有完成兩個線程交替打印的目的，甚至數(shù)據(jù)的打印都非常地亂。這是因為i是臨界資源，多個線程爭搶訪問臨界資源可能會造成數(shù)據(jù)二義，線程是不安全的，需要保證任意時刻只有一個線程能夠訪問臨界資源。

所以創(chuàng)建一個互斥量，并在臨界區(qū)合適的地方加鎖和解鎖。由于線程的執(zhí)行函數(shù)我使用了lambda表達(dá)式，為了讓兩個線程使用的是同一把鎖，把鎖創(chuàng)建在了main函數(shù)內(nèi)，并在lambda表達(dá)式內(nèi)使用了引用捕捉。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int main(void)
{
	int n = 100;
	int i = 0;
	mutex mtx;
	//創(chuàng)建兩個線程
	thread t1([&n, &i, &mtx](){
		while (i < n)
		{
			mtx.lock();
			cout << this_thread::get_id()  << ": " << i << endl;
			i++;
			mtx.unlock();
		}
	});
	thread t2([&n, &i, &mtx]() {
		while (i < n)
		{
			mtx.lock();
			cout << this_thread::get_id() << ": " << i << endl;
			i++;
			mtx.unlock();
		}
	});
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

在C++中，一般不直接操作鎖，而是由類去管理鎖。

//第一個管理鎖的類
template <class Mutex> class lock_guard;
//第二個管理鎖的類
template <class Mutex> class unique_lock;

lock_guar類，只有構(gòu)造和析構(gòu)函數(shù)。一般用于加鎖和解鎖，這里進(jìn)行簡單的模擬：

//注意：為了使得加鎖和解鎖的是同一把鎖
//需要使用引用
template <class Lock>
class LockGuard
{
public:
	LockGuard(Lock &lck)
		:_lock(lck)
	{
		_lock.lock();
	}
	~LockGuard()
	{
		_lock.unlock();
	}
private:
	Lock &_lock;
};

unique_lock的成員方法就不僅僅是析構(gòu)函數(shù)和構(gòu)造函數(shù)。詳見文檔unique_lock介紹和使用。

這里將鎖交給unique_lock類的對象進(jìn)行管理。

int main(void)
{
	int n = 100;
	int i = 0;
	mutex mtx;
	//創(chuàng)建兩個線程
	thread t1([&n, &i, &mtx, &cv, &flag](){
		while (i < n)
		{
			unique_lock<mutex> LockManage(mtx);
			cout << this_thread::get_id()  << ": " << i << endl;
			i++;
		}
	});
	thread t2([&n, &i, &mtx, &cv, &flag]() {
		while (i < n)
		{
			unique_lock<mutex> LockManage(mtx);
			cout << this_thread::get_id() << ": " << i << endl;
			i++;
		}
	});
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

線程是安全了，但如果其中一個線程競爭鎖的能力比較強，那么可能會出現(xiàn)上面這種情況。

需要控制：一個線程執(zhí)行一次后，如果再次去執(zhí)行就不準(zhǔn)許了，同時可以喚醒另一個進(jìn)程去執(zhí)行，如此循環(huán)往復(fù)達(dá)到交替打印的目的。所以可以增加一個條件變量，讓某個線程在該條件變量下的阻塞隊列等待。

C++庫中線程在條件變量下的等待函數(shù)第一個參數(shù)注意是管理鎖的類對象

int main(void)
{
	int n = 100;
	int i = 0;
	mutex mtx;
	condition_variable cv;
	bool flag = false;
	//創(chuàng)建兩個線程
	thread t1([&n, &i, &mtx, &cv, &flag](){
		while (i < n)
		{
			unique_lock<mutex> LockManage(mtx);
			//!flag為真，那么獲取后不會阻塞，優(yōu)先運行
			cv.wait(LockManage, [&flag]() {return !flag; });
			cout << this_thread::get_id()  << ": " << i << endl;
			i++;
		}
	});
	thread t2([&n, &i, &mtx, &cv, &flag]() {
		while (i < n)
		{
			unique_lock<mutex> LockManage(mtx);
			//flag為假，競爭到鎖后，由于條件不滿足，阻塞
			cv.wait(LockManage, [&flag]() {return flag; });
			cout << this_thread::get_id() << ": " << i << endl;
			i++;
		}
	});
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

這里flag以及l(fā)ambda表達(dá)式的增加是非常巧妙的。flag的初始化值為false,讓線程t2在[&flag]() {return false; }下等待，那么t2線程就會先執(zhí)行。

線程t1競爭到了鎖，但是由于不滿足條件，會繼續(xù)等待，所以就出現(xiàn)了上面的情況。

需要一個線程喚醒另一個線程之前，將flag的值進(jìn)行修改。

int main(void)
{
	int n = 100;
	int i = 0;
	mutex mtx;
	condition_variable cv;
	bool flag = false;
	//創(chuàng)建兩個線程
	thread t1([&n, &i, &mtx, &cv, &flag](){
		while (i < n)
		{
			unique_lock<mutex> LockManage(mtx);
			//!flag為真，那么獲取后不會阻塞，優(yōu)先運行
			cv.wait(LockManage, [&flag]() {return !flag; });
			cout << this_thread::get_id()  << ": " << i << endl;
			i++;
			flag = true;
			cv.notify_one();
		}
	});
	thread t2([&n, &i, &mtx, &cv, &flag]() {
		while (i < n)
		{
			unique_lock<mutex> LockManage(mtx);
			//flag為假，競爭到鎖后，由于條件不滿足，阻塞
			cv.wait(LockManage, [&flag]() {return flag; });
			cout << this_thread::get_id() << ": " << i << endl;
			i++;
			flag = false;
			cv.notify_one();
		}
	});
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

最終，實現(xiàn)了兩個線程交替打?。ㄒ粋€線程打印奇數(shù)、一個線程打印偶數(shù)）