<一>、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 
#include 
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 
#include 
#include 
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 
#include 
#include 
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 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 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 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 
#include 
#include 
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 ul(g_mutex); // 唯一锁,实例化时,自动加锁,离开作用域调析构自动解锁
			lock_guard 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 ul(g_mutex);
			lock_guard 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 ul(g_mutex);
			lock_guard 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博客

六、输出结果展示:

<一>、C++实现多线程的同步处理:控制ABC的输出顺序,输出10组,mutex+condition_variable_第1张图片

你可能感兴趣的:(C++随想录,c++,数据结构,开发语言)