＜一＞、C++实现多线程的同步处理:控制ABC的输出顺序,输出10组，mutex+condition_variable

目录

需求：

分析：

一些代码实现：

一、只用标志位来实现的操作：

二、为了更加安全，加了互斥锁的代码：

三、配合唯一锁unique_lock使用，代码更安全

四：使用守卫锁 lock_guard 来配合使用

五、还可以使用条件变量来处理，会变得更加效率

六、输出结果展示：

---

需求：

        有三条线程，可以分别输出A、B、C字符，现想办法控制输出顺序，使得顺序为ABCABC......ABC[共10组]，并且每条线程只能启动一次，不能多次启动。

分析：

        要在标准C++中使用多线程，可以使用类 thread,3条线程，我们可以直白一些，直接实现3个线程函数，在函数里面进行循环输出对应字符，每个循环控制10次即可；

        同时，要想控制输出顺序的话，最开始想到的方式是直接加一个标志位来控制，也是极好的，也基本上能实现ABC的输出效果；

        通过一个标志位来处理的方式虽然可以实现效果，但是还不够安全，极有可能有多条线程同时操作一个全局变量，导致资源争夺问题，为了保证安全，可以在此基础上加上对应的锁来处理同步问题，比如加上互斥锁 mutex,就可以有效的防止资源争夺问题。

        既然已经使用了mutex锁了，能不能在此基础上再优化以下，配合守卫锁 lock_guard 或者唯一锁 unique_lock 来解决可能导致的异常死锁问题。

一些代码实现：

一、只用标志位来实现的操作：

#include <iostream>
#include <thread>
using namespace std;

int g_flag = 0; // 全局标志位  0输出A,1输出B，2输出C
void outA()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 0) {  // 标志位为0 输出 A
			cout << "A"; // 输出目标字符A
			++i;	// 次数自增
			g_flag = 1; // 修改标志位为1 让B输出
		}
		// if条件不成立，就会一直死循环
	}
}
void outB()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 1) { // 标志位为1 输出 B
			cout << "B";
			++i;
			g_flag = 2; // 修改标志位为2 接着让C输出
		}
	}
}
void outC()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 2) {  // 标志位为2 输出 C
			cout << "C";
			++i;
			g_flag = 0; // 修改标志位为0，让A输出
		}
	}
}

int main()
{
	thread tA(&outA); // A的线程
	tA.detach();
	thread tB(&outB); // B的线程
	tB.detach();
	thread tC(&outC); // C的线程
	tC.join(); // 最后一条线程需要用join来阻塞，防止主函数立即结束
    return 0;
}

二、为了更加安全，加了互斥锁的代码：

#include <iostream>
#include <mutex>
#include <thread>
using namespace std;

int g_flag = 0; // 全局标志位  0输出A,1输出B，2输出C
mutex g_mutex;

void outA()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 0) {  // 标志位为0 输出 A
			cout << "A"; // 输出目标字符A
			++i;	// 次数自增
			g_mutex.lock();
			g_flag = 1; // 修改标志位为1 让B输出
			g_mutex.unlock();
		}
		// if条件不成立，就会一直死循环
	}
}
void outB()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 1) { // 标志位为1 输出 B
			cout << "B";
			++i;
			g_mutex.lock();
			g_flag = 2; // 修改标志位为2 接着让C输出
			g_mutex.unlock();
		}
	}
}
void outC()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 2) {  // 标志位为2 输出 C
			cout << "C";
			++i;
			g_mutex.lock();
			g_flag = 0; // 修改标志位为0，让A输出
			g_mutex.unlock();
		}
	}
}

int main()
{
	thread tA(&outA); // A的线程
	tA.detach();
	thread tB(&outB); // B的线程
	tB.detach();
	thread tC(&outC); // C的线程
	tC.join(); // 最后一条线程需要用join来阻塞，防止主函数立即结束
    return 0;
}

三、配合唯一锁unique_lock使用，代码更安全

#include <iostream>
#include <mutex>
#include <thread>
using namespace std;

int g_flag = 0; // 全局标志位  0输出A,1输出B，2输出C
mutex g_mutex;

void outA()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 0) {  // 标志位为0 输出 A
			cout << "A"; // 输出目标字符A
			++i;	// 次数自增
			//g_mutex.lock();
			unique_lock<mutex> ul(g_mutex); // 唯一锁，实例化时，自动加锁，离开作用域调析构自动解锁
			g_flag = 1; // 修改标志位为1 让B输出
			//g_mutex.unlock();
		}
		// if条件不成立，就会一直死循环
	}
}
void outB()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 1) { // 标志位为1 输出 B
			cout << "B";
			++i;
			//g_mutex.lock();
			unique_lock<mutex> ul(g_mutex);
			g_flag = 2; // 修改标志位为2 接着让C输出
			//g_mutex.unlock();
		}
	}
}
void outC()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 2) {  // 标志位为2 输出 C
			cout << "C";
			++i;
			//g_mutex.lock();
			unique_lock<mutex> ul(g_mutex);
			g_flag = 0; // 修改标志位为0，让A输出
			//g_mutex.unlock();
		}
	}
}

int main()
{
	thread tA(&outA); // A的线程
	tA.detach();
	thread tB(&outB); // B的线程
	tB.detach();
	thread tC(&outC); // C的线程
	tC.join(); // 最后一条线程需要用join来阻塞，防止主函数立即结束
    return 0;
}

四：使用守卫锁 lock_guard 来配合使用

#include <iostream>
#include <mutex>
#include <thread>
using namespace std;

int g_flag = 0; // 全局标志位  0输出A,1输出B，2输出C
mutex g_mutex;

void outA()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 0) {  // 标志位为0 输出 A
			cout << "A"; // 输出目标字符A
			++i;	// 次数自增
			//g_mutex.lock();
			//unique_lock<mutex> ul(g_mutex); // 唯一锁，实例化时，自动加锁，离开作用域调析构自动解锁
			lock_guard<mutex> lg(g_mutex); // 守卫锁，也能起到自动加锁，自动解锁的作用
			g_flag = 1; // 修改标志位为1 让B输出
			//g_mutex.unlock();
		}
		// if条件不成立，就会一直死循环
	}
}
void outB()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 1) { // 标志位为1 输出 B
			cout << "B";
			++i;
			//g_mutex.lock();
			//unique_lock<mutex> ul(g_mutex);
			lock_guard<mutex> lg(g_mutex); // 守卫锁，也能起到自动加锁，自动解锁的作用
			g_flag = 2; // 修改标志位为2 接着让C输出
			//g_mutex.unlock();
		}
	}
}
void outC()
{
	for (int i = 0; i < 10;) {
		if (g_flag == 2) {  // 标志位为2 输出 C
			cout << "C";
			++i;
			//g_mutex.lock();
			//unique_lock<mutex> ul(g_mutex);
			lock_guard<mutex> lg(g_mutex); // 守卫锁，也能起到自动加锁，自动解锁的作用
			g_flag = 0; // 修改标志位为0，让A输出
			//g_mutex.unlock();
		}
	}
}

int main()
{
	thread tA(&outA); // A的线程
	tA.detach();
	thread tB(&outB); // B的线程
	tB.detach();
	thread tC(&outC); // C的线程
	tC.join(); // 最后一条线程需要用join来阻塞，防止主函数立即结束
    return 0;
}

五、还可以使用条件变量来处理，会变得更加效率

        由于篇幅较长，请到下一篇文档来查看关于条件变量和互斥锁的配合使用

＜二＞、C++实现多线程的同步处理:控制ABC的输出顺序,输出10组，mutex+condition_variable-CSDN博客

六、输出结果展示：