3.C++应用 多线程之线程之间共享数据、互斥锁

最新推荐文章于 2024-03-24 15:33:42 发布
最新推荐文章于 2024-03-24 15:33:42 发布
阅读量598 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50832904/article/details/121591214
版权

 线程之间访问同一变量：g_number

#include<iostream>
#include"osapi/osapi.h"
using namespace std;
int g_number = 10086;

class TaskA : public OS_Thread
{
public:
	bool quitflag;
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		while (!quitflag) 
		{
			cout << "TaskA:" << g_number << endl;
			OS_Thread::Msleep(1000);
		}
		cout << "TaskA Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

class TaskB : public OS_Thread
{
public:
	bool quitflag;
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		while (!quitflag)
		{
			cout << "TaskB:" << g_number << endl;
			OS_Thread::Msleep(1000);
		}
		cout << "TaskB Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

int main()//主线程
{
	TaskA task1;
	task1.start();
	
	TaskB task2;
	task2.start();

	cout << "---main routine is running----" << endl;

	getchar();
	task1.stop();
	task2.stop();

	cout << "退出程序" << endl;

	return 0;
}

现在要对一个数组操作，要求一个进程生成元素相同的数组，另外一个进程对数组操作，但是保证操作前，这个数组每个元素都要相同

#include<iostream>
#include"osapi/osapi.h"
using namespace std;
int g_RW[16];
class TaskA : public OS_Thread
{
public:
	bool quitflag;
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		int times = 0;
		while (!quitflag) 
		{
			cout << "生成数组：";
			for (int i = 0; i < 16; i++)
			{
				OS_Thread::Msleep(5);//每5毫秒执行一次操作,加长访问时间
				g_RW[i] = times;//这个线程对数据操作，生成每个元素都是一样的数组
				cout << g_RW[i]<<" ";
			}
			cout << endl;
			OS_Thread::Msleep(100);
			if (times++ == 128) times = 0;
		}
		cout << "TaskA Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

class TaskB : public OS_Thread
{
public:
	bool quitflag;
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		while (!quitflag)
		{
			cout << "校验数组：";
			for (int i = 0; i < 15;i++)
			{
				OS_Thread::Msleep(5);//每5毫秒执行一次操作,加长访问时间
				if (g_RW[i] != g_RW[i + 1])
					cout << "g_RW[" << i << "]元素出错=" << g_RW[i] << endl;//这个线程对数组访问，要求数组每个元素都一样
				cout << g_RW[i]<<" ";
			}
			cout << g_RW[15] << endl;
			OS_Thread::Msleep(100);
		}
		cout << "TaskB Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

int main()//主线程
{
	TaskA task1;
	task1.start();
	
	TaskB task2;
	task2.start();

	cout << "---main routine is running----" << endl;
	//OS_Thread::Msleep(1000);
	getchar();
	task1.stop();
	task2.stop();

	cout << "退出程序" << endl;

	return 0;
}

发现数组元素总是出错，操作系统发现一个进程运行的时间到了就会去切换运行另外一个进程，无法保证数据准确，怎么解决，引入互斥锁机制

互斥锁，C++里一般称为Mutex，Java里则一般称为Lock

互斥锁的使用

“在访问共享数据前，先获取锁，访问完成后，释放锁”

互斥锁机制：

“在一个线程获取锁之后，另一个线程的Lock操作会一直等待（阻塞），直到该锁被释放（unlock）”

#include<iostream>
#include"osapi/osapi.h"
using namespace std;
int g_RW[16];
OS_Mutex g_mutex;
class TaskA : public OS_Thread
{
public:
	bool quitflag;
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		int times = 0;
		while (!quitflag) 
		{
			g_mutex.Lock();//只有获取锁，才能执行如下程序
			cout << "生成数组：";
			for (int i = 0; i < 16; i++)
			{
				OS_Thread::Msleep(5);//每5毫秒执行一次操作,加长访问时间
				g_RW[i] = times;//这个线程对数据操作，生成每个元素都是一样的数组
				cout << g_RW[i]<<" ";
			}
			cout << endl;
			g_mutex.Unlock();//程序运行完成，释放锁
			OS_Thread::Msleep(100);
			if (times++ == 128) times = 0;
		}
		cout << "TaskA Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

class TaskB : public OS_Thread
{
public:
	bool quitflag;
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		while (!quitflag)
		{
			g_mutex.Lock();//只有获取锁，才能执行如下程序
			cout << "校验数组：";
			for (int i = 0; i < 15;i++)
			{
				OS_Thread::Msleep(5);//每5毫秒执行一次操作,加长访问时间
				if (g_RW[i] != g_RW[i + 1])
					cout << "g_RW[" << i << "]元素出错=" << g_RW[i] << endl;//这个线程对数组访问，要求数组每个元素都一样
				cout << g_RW[i]<<" ";
			}
			cout << g_RW[15] << endl;
			g_mutex.Unlock();//程序运行完成，释放锁
			OS_Thread::Msleep(100);
		}
		cout << "TaskB Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

int main()//主线程
{
	TaskA task1;
	task1.start();
	
	TaskB task2;
	task2.start();

	cout << "---main routine is running----" << endl;
	//OS_Thread::Msleep(1000);
	getchar();
	task1.stop();
	task2.stop();

	cout << "退出程序" << endl;

	return 0;
}

如果一个线程拥有锁时间太长，别的线程等待这个锁，导致效率太低了

#include<iostream>
#include"osapi/osapi.h"
using namespace std;
int g_RW[16] = { 0,0,0,0,0,0,0,0, 0,0,0,0, 0,0,0,0};
OS_Mutex g_mutex;
class TaskA : public OS_Thread
{
public:
	bool quitflag;
	TaskA() :quitflag(true) {}
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		int temp[16]={ 0,0,0,0,0,0,0,0, 0,0,0,0, 0,0,0,0 };
		int times = 0;
		while (!quitflag) 
		{
			cout << "生成数组：";
			for (int i = 0; i < 16; i++)
			{
				temp[i] = times;//这个线程对数据操作，生成每个元素都是一样的数组
				cout << temp[i]<<" ";
			}
			cout << endl;
			if (times++ == 128) times = 0;

			//由于生成时间太慢了，但是锁要及时释放
			//我们让数据生成完成后，在调用执行锁里面的程序，程序占用锁时间大大缩短
			g_mutex.Lock();
			memcpy(g_RW, temp, 16*4);
			g_mutex.Unlock();

		}
		cout << "TaskA Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

class TaskB : public OS_Thread
{
public:
	bool quitflag;
	TaskB() :quitflag(true) {}
	void start()
	{
		quitflag = false;
		Run();
	}
	void stop()
	{
		quitflag = true;
		Join(this);
	}
private:
	virtual int Routine()
	{
		int temp[16] = { 0,0,0,0,0,0,0,0, 0,0,0,0, 0,0,0,0 };
		while (!quitflag)
		{
			g_mutex.Lock();//只有获取锁，才能执行如下程序
			memcpy(temp, g_RW, 16*4);
			g_mutex.Unlock();//程序运行完成，释放锁
			//尽量缩短对共享数据访问时间

			cout << "校验数组：";
			for (int i = 0; i < 15;i++)
			{				
				if (temp[i] != temp[i + 1])
					cout << "元素出错=" << temp[i] << endl;//这个线程对数组访问，要求数组每个元素都一样
				cout << temp[i]<<" ";
			}
			cout << temp[15] << endl;
		}
		cout << "TaskB Exit !" << endl;
		cout << "Save Data !" << endl;
		return 0;
	}
};

int main()//主线程
{
	TaskA task1;
	task1.start();


	TaskB task2;
	task2.start();

	cout << "---main routine is running----" << endl;
	getchar();
	task1.stop();
	task2.stop();

	cout << "退出程序" << endl;

	return 0;
}

1.多个线程之间，可以通过全局对象/堆对象来共享数据

2.当访问共享数据时（又读又写），为了保证数据的完整性，需要使用互斥锁机制

3.一个使用原则：尽量缩短对lock的占用时间

基本模型与排列组合
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
280-C++互斥锁 条件变量
weixin_45964837的博客
03-28 996
1.如果g_num是原子的，就是说线程a++g_num的时候线程b不能++，线程b++g_num的时候，线程a不能++，所以最后的结果总是为11，而如果g_num不是原子的，那最后的结果有可能是11也有可能不是11 在定义g_num的时候就算加上volatile易变关键字也依然是不正确的 2.互斥量的头文件是#include ...
6.C++中多线程.docx
11-23
C++多线程编程基础知识 本篇文章将详细介绍C++中多线程编程的基础知识，涵盖多线程的创建、线程之间的通信、线程加锁和线程解锁等方面的知识点。 一、多线程的创建 在C++中，使用std::thread类来创建线程。线程的...
c++多线程thread操作（八）父线程传递数据给子线程
BearLeer的博客
06-28 2537
实现父线程和子线程的交互 1. 实现方式： 主线程定义promise，然后在主线程中设定promise的数据，子线程可以直接从主线程的promise中获取数据； int factorial(future<int>&f) {//将结果返回给x int res = 1; int N = f.get();//主线程不set_value，会发生异常 for (int i = N; i > 1; i--) { res *= i; } cout << "res
【C++】互斥量解决多线程数据共享问题
最新发布
2301_79867980的博客
03-24 315
当多个线程访问同一变量时，并且其中至少有一个线程对变量进行了写操作，就会出现数据竞争问题。数据竞争问题可以使用同步机制来确保多个线程之间对共享数据的访问是安全的。常见的同步机制包括互斥量、条件变量、、原子操作等。
C++类中定义线程
Kevin的专栏
08-27 7299
1. C++ 中如何定义线程函数      有两种方法：a. 定义线程函数为全局函数    b. 定义线程函数为类的静态成员函数 2. C++中的线程函数如何访问类中的成员变量     针对线程函数为类的静态成员进行说明。如果是静态数据成员，当然可以直接访问，但是如果要访问非静态数据成员，直接访问是做不到的。如果要想在线程函数中访问和操作类的非静态成员变量，可以把线程
C++多线程同时读写变量
Zhongjiaxiang_hi的专栏
11-12 3911
关于同时读写变量的问题： 多个线程同时写一变量会否造成问题【c++吧】_百度贴吧 Saingel ：不一定，要看哪种了，stdstring那种随写入操作而内存位置或大小变更的对象肯定会有问题，如果是在固定的内存上写，不写出界基本没问题，最多运算结果会错 //Sample 同时读写变量 #include <pthread.h> #include <string.h> #include <stdio.h> #include <time.h> void .
ESP8266学习笔记（4）——定时器接口使用（NONOS SDK）
Leung的博客
11-16 3304
一、软件定时器 1.1 简介 以下软件定时器接口位于 /ESP8266_NONOS_SDK/include/osapi.h。请注意，以下接口 使用的定时器由软件实现，定时器的函数在任务中被执行。因为任务可能被中断，或者被 其他高优先级的任务延迟，因此以下 os_timer 系列的接口并不能保证定时器精确执行。 如果需要精确的定时，例如，周期性操作某 GPIO，请使用硬件中断定时器，具体可参考 hw...
C++多线程中的锁和条件变量使用教程
08-26
在C++多线程编程中，锁和条件变量是两个非常重要的概念，它们都是用于解决多线程之间的同步和通信问题的。下面我们将详细地介绍锁和条件变量的使用。 一、锁（Mutex） 锁是多线程编程中最基本的同步机制，它用于...
Linux c++多线程串口编程demo
01-26
使用多线程进行串口编程，获取串口数据，利用互斥锁和信号量在不同的线程中安全地操作数据，希望该demo能帮助你快速理解并掌握上述知识。
C++多线程编程时的数据保护
09-03
总结来说，C++11提供了多种工具来解决多线程编程中的数据保护问题。通过正确使用这些同步原语，我们可以确保数据的一致性和正确性，防止竞争条件和其他并发问题的发生。在编写多线程程序时，理解这些概念以及如何在...
共享内存多线程数据交换（C++）
01-31
前几天学习共享内存，和多线程应用写了个小程序，给初学者一点帮助
osapi 跨平台系统API封装 for C
05-15
为跨平台(win32/linux)编程而设计的一套系统API，封装了thread,socket, mutex, semaphore, sharedmemory, int type等接口和类型。开发者使用这套接口来开发C程序时，可以做到在不同的平台上只需要一套代码，可以无视windows/linux中对线程、互斥的实现上的差异。本人使用多年，久经考验，可放心使用。 (这是C版本，C++开发人员请直接下载C++版本) - 特为中国的开发人员奉献！
多线程使用同一数组测试
04-02
多线程使用同一个数组引起错误的可能性分析，经目前测试，在经过了30万次运算后，没有出现错误，不知道是不是测试正确，求高手指点。
C++ 多线程同步，访问同一变量，加锁
热门推荐
u011848173的博客
02-22 1万+
一、临界区 临界区又称关键代码段，指的是一小段代码在代码执行前，他需要独占一些资源。程序中通常将多线程同时访问的某个资源作为临界区，需要定义一个CRITICAL_SECTION类型的变量，然后调用InitializeCriticalSection函数对变量进行初始化； 函数声明： VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriti...
Linux多线程编程-线程互斥锁
weixin_43587255的博客
05-11 864
描述 通过下面的练习加深对线程的概念的理解，同时明确线程的控制。从而进一步了解线程的互斥，并学会利用pthread库。 要求 定义一个用于互斥的互斥锁、和一个主函数和两个子线程都能访问的共享变量，一个主函数和两个用来创建子线程的子函数;在主函数中定义两个子线程ID的变量，初始化互斥锁，创建对应函数的子线程，等待两个子线程运行结束，获取并打印共享变量的结果，销毁互斥锁并返回退出。 实现代码 #inc...
【多线程编程学习笔记8】使用互斥锁实现线程同步
qq_41854911的博客
07-14 1991
申明：本学习笔记是在该教程的基础上结合自己的学习情况进行的总结，不是原创，想要看原版的请看C语言中文网的多线程编程（C语言+Linux），该网站有很多好的编程学习教程，尤其是关于C语言的。 在《线程同步机制》一节讲到，实现多线程同步的常用方法有 4 种，互斥锁是其中最简单也最有效地的方法。本节，我们就为您详细讲解互斥锁的具体用法。 互斥锁实现多线程同步的核心思想是：有线程访问进程空间中的公共资源时，该线程执行“加锁”操作（将资源“锁”起来），阻止其它线程访问。访问完成后，该线程负责完成“解锁”操作，将资.
【Java并发编程】Java多线程（二）：多线程一定好吗？线程阻塞时占用CPU吗？
A minor
09-14 6291
1.多线程一定好吗 1.1 适用场景 阻塞等待时充分利用CPU 当程序发生阻塞的操作时候，例如IO等待，CPU将就空闲下来了。而使用多线程，当一些线程发生阻塞的时候，另一些线程则仍能利用CPU，而不至于让CPU一直空闲。 利用CPU的多核并行计算能力 现在的CPU基本上都是多核的。使用多线程，可以利用多核同时执行多个线程，而不至于单线程时一个核心满载，而其他核心空闲。 1.2 多线程弊端 线程切换是有开销的，这会导致程序运行变慢。 多线程程序必须非常小心地同步代码，否则会引起死锁。 多线程程序极难调试
qt高级 多线程 互斥锁
08-16
1. QMutex 类：QMutex 是 Qt 提供的互斥锁类，用于在多线程环境中保护共享资源。可以使用 QMutex 的 lock() 和 unlock() 方法来实现对共享资源的加锁和解锁操作。 2. QMutexLocker 类：QMutexLocker 是一个便利类，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值