c++共享内存（二）：通过两个共享内存地址块实现程序A和B的相互通信，并通过CreateSemaphore同步线程，防止程序A和B同时访问同一块内存块

最新推荐文章于 2024-05-15 00:45:20 发布

GreenHandBruce

最新推荐文章于 2024-05-15 00:45:20 发布

阅读量1.7k

点赞数 1

分类专栏： VS2015&C++控制台程序文章标签：共享内存信号量同步 c++

本文链接：https://blog.csdn.net/weixin_43935474/article/details/86765843

版权

VS2015&C++控制台程序专栏收录该内容

6 篇文章 1 订阅

订阅专栏

在“c++共享内存（一）”中，我写了一个demo，实现了
程序A接受到用户输入的字符串后存放到共享内存中，程序B收到用户输入任意字符的操作之后会从共享内存中读取该字符串并显示在控制台中。
但这有个问题，如果程序A在放数据的同时，程序B就从该内存块中取数据，则必会发生冲突，引起程序崩溃。解决该问题的方法就是使用CreateSemaphore同步线程，防止程序A和B同时访问同一块内存块。
程序A代码如下：

// CreateFileMapping_ProgramA.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<iostream>
#include <windows.h>
#include <process.h>
using namespace std;

#define BUF_SIZE 1024
wstring   m_cstrSzName[2];//共享内存名（一共两个，一个给A放数据，由B取数据；一个给B放数据，由A取数据）
wstring   m_ReadSemaphoreName[2];//读数据的信号量名
wstring   m_WriteSemaphoreName[2];//写数据的信号量名
HANDLE  m_hMapFile[2];//共享内存句柄
char    *m_pBuf[2];//读取数据的缓存
HANDLE	m_Read[2];//读数据的信号量句柄
HANDLE  m_Write[2];//写数据的信号量句柄
void CloseFileMap()
{
	for (int i=0;i<2;i++)
	{
		//4.撤销文件视图UnMapViewOfFile()
		UnmapViewOfFile(m_pBuf[i]);
		//5.关闭映射文件句柄CloseHandle()
		CloseHandle(m_hMapFile[i]);
	}
}
void CreateFileMap()
{
	m_cstrSzName[0] = L"NameOfMappingObject0";//共享内存0的名字，程序A和B中对该变量的命名必须相同！
	m_cstrSzName[1] = L"NameOfMappingObject1";//共享内存1的名字，程序A和B中对该变量的命名必须相同！
	m_ReadSemaphoreName[0] = L"ReadSemaphoreName0";//读信号量0的名字，程序A和B中对该变量的命名必须相同！
	m_ReadSemaphoreName[1] = L"ReadSemaphoreName1";//读信号量1的名字，程序A和B中对该变量的命名必须相同！
	m_WriteSemaphoreName[0] = L"WriteSemaphoreName0";//写信号量0的名字，程序A和B中对该变量的命名必须相同！
	m_WriteSemaphoreName[1] = L"WriteSemaphoreName1";//写信号量1的名字，程序A和B中对该变量的命名必须相同！
	for (int i=0;i<2;i++)
	{
		//1.创建共享文件句柄 hMapFile，CreateFileMapping()函数创建一个文件映射内核对象
		m_hMapFile[i] = CreateFileMapping(
			INVALID_HANDLE_VALUE,     //物理文件句柄，设为INVALID_HANDLE_VALUE（无效句柄）以创建一个进程间共享的对象
			NULL,				      //默认安全级别
			PAGE_READWRITE,           //权限可读可写
			0,						  //高位文件大小
			BUF_SIZE,				  //低位文件大小
			m_cstrSzName[i].c_str()			  //共享内存名
		);
		//2.获取指向文件视图的指针 pBuf，MapViewOfFile()函数负责把文件数据映射到进程的地址空间
		m_pBuf[i] = (char*)MapViewOfFile(
			m_hMapFile[i],				  //共享内存的句柄
			FILE_MAP_ALL_ACCESS,      //可读写
			0,
			0,
			BUF_SIZE
		);
	}
	m_Read[0] = CreateSemaphore(NULL, 0, 1, m_ReadSemaphoreName[0].c_str());
	m_Write[0] = CreateSemaphore(NULL, 1, 1, m_WriteSemaphoreName[0].c_str());
	m_Read[1] = CreateSemaphore(NULL, 0, 1, m_ReadSemaphoreName[1].c_str());
	m_Write[1] = CreateSemaphore(NULL, 1, 1, m_WriteSemaphoreName[1].c_str());
}
unsigned int __stdcall WriteSharedData(void *pPM)
{
	//3.将数据放到共享内存
	while (true)
	{
		//通过m_pBuf[0]向共享内存m_hMapFile[0]发送数据
		WaitForSingleObject(m_Write[0], INFINITE);
		cout << "input..." << endl;
		char szInfo[BUF_SIZE] = { 0 };
		gets_s(szInfo, BUF_SIZE);//c++11中用gets_s() 代替gets()
		memcpy(m_pBuf[0], szInfo, BUF_SIZE - 1);
		ReleaseSemaphore(m_Read[0], 1, NULL);
	}
	return true;
}
unsigned int __stdcall ReadSharedData(void *pPM)
{
	//3.从共享内存中读取数据
	while (true)
	{
		WaitForSingleObject(m_Read[1], INFINITE);//m_Read[1]信号量由程序B增加
		cout << m_pBuf[1] << endl;
		ReleaseSemaphore(m_Write[1],1,NULL);
	}
	return true;
}
int main()
{
	CreateFileMap();//创建共享内存
	UINT threadId;
	HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, WriteSharedData, 0, 0, &threadId);//创建写数据的线程
	if (hThread == NULL)
	{
		cout << "Starting WriteSharedData Thread  Failed!" << endl;
	}
	HANDLE hThread2 = (HANDLE)_beginthreadex(NULL, 0, ReadSharedData, 0, 0, &threadId);//创建读数据的线程
	if (hThread2 == NULL)
	{
		cout << "Starting ReadSharedData Thread  Failed!" << endl;
	}
	Sleep(1000000);//程序开始运行后1000s后自动关闭
	CloseFileMap();
	return 0;
}

程序B代码如下：

// CreateFileMapping_ProgramB.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<iostream>
#include <windows.h>
#include <process.h>
using namespace std;

#define BUF_SIZE 1024
wstring   m_cstrSzName[2];//共享内存名（一共两个，一个给A放数据，由B取数据；一个给B放数据，由A取数据）
wstring   m_ReadSemaphoreName[2];//读数据的信号量名
wstring   m_WriteSemaphoreName[2];//写数据的信号量名
HANDLE  m_hMapFile[2];//共享内存句柄
char    *m_pBuf[2];//读取数据的缓存
HANDLE	m_Read[2];//读数据的信号量句柄
HANDLE  m_Write[2];//写数据的信号量句柄
void CloseFileMap()
{
	for (int i = 0; i < 2; i++)
	{
		//4.撤销文件视图UnMapViewOfFile()
		UnmapViewOfFile(m_pBuf[i]);
		//5.关闭映射文件句柄CloseHandle()
		CloseHandle(m_hMapFile[i]);
	}
}
void CreateFileMap()
{
	m_cstrSzName[0] = L"NameOfMappingObject0";//共享内存0的名字，程序A和B中对该变量的命名必须相同！
	m_cstrSzName[1] = L"NameOfMappingObject1";//共享内存1的名字，程序A和B中对该变量的命名必须相同！
	m_ReadSemaphoreName[0] = L"ReadSemaphoreName0";//读信号量0的名字，程序A和B中对该变量的命名必须相同！
	m_ReadSemaphoreName[1] = L"ReadSemaphoreName1";//读信号量1的名字，程序A和B中对该变量的命名必须相同！
	m_WriteSemaphoreName[0] = L"WriteSemaphoreName0";//写信号量0的名字，程序A和B中对该变量的命名必须相同！
	m_WriteSemaphoreName[1] = L"WriteSemaphoreName1";//写信号量1的名字，程序A和B中对该变量的命名必须相同！
	for (int i = 0; i < 2; i++)
	{
		//1.创建共享文件句柄 hMapFile，CreateFileMapping()函数创建一个文件映射内核对象
		m_hMapFile[i] = CreateFileMapping(
			INVALID_HANDLE_VALUE,     //物理文件句柄，设为INVALID_HANDLE_VALUE（无效句柄）以创建一个进程间共享的对象
			NULL,				      //默认安全级别
			PAGE_READWRITE,           //权限可读可写
			0,						  //高位文件大小
			BUF_SIZE,				  //低位文件大小
			m_cstrSzName[i].c_str()			  //共享内存名
		);
		//2.获取指向文件视图的指针 pBuf，MapViewOfFile()函数负责把文件数据映射到进程的地址空间
		m_pBuf[i] = (char*)MapViewOfFile(
			m_hMapFile[i],				  //共享内存的句柄
			FILE_MAP_ALL_ACCESS,      //可读写
			0,
			0,
			BUF_SIZE
		);
	}
	m_Read[0] = CreateSemaphore(NULL, 0, 1, m_ReadSemaphoreName[0].c_str());
	m_Write[0] = CreateSemaphore(NULL, 1, 1, m_WriteSemaphoreName[0].c_str());
	m_Read[1] = CreateSemaphore(NULL, 0, 1, m_ReadSemaphoreName[1].c_str());
	m_Write[1] = CreateSemaphore(NULL, 1, 1, m_WriteSemaphoreName[1].c_str());
}
unsigned int __stdcall WriteSharedData(void *pPM)
{
	//3.将数据放到共享内存
	while (true)
	{
		//通过m_pBuf[0]向共享内存m_hMapFile[0]发送数据
		WaitForSingleObject(m_Write[1], INFINITE);
		cout << "input..." << endl;
		char szInfo[BUF_SIZE] = { 0 };
		gets_s(szInfo, BUF_SIZE);//c++11中用gets_s() 代替gets()
		memcpy(m_pBuf[1], szInfo, BUF_SIZE - 1);
		ReleaseSemaphore(m_Read[1], 1, NULL); //m_Read[1]增加一个信号量，由程序A中的WaitForSingleObject(m_Read[1], INFINITE);获取到该信号量之后输出m_pBuf[1]内存块的数据
	}
	return true;
}
unsigned int __stdcall ReadSharedData(void *pPM)
{
	//3.从共享内存中读取数据
	while (true)
	{
		WaitForSingleObject(m_Read[0], INFINITE);//m_Read[1]信号量由程序B增加
		cout << m_pBuf[0] << endl;
		ReleaseSemaphore(m_Write[0], 1, NULL);
	}
	return true;
}
int main()
{
	CreateFileMap();//创建共享内存
	UINT threadId;
	HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, WriteSharedData, 0, 0, &threadId);//创建写数据的线程
	if (hThread == NULL)
	{
		cout << "Starting WriteSharedData Thread  Failed!" << endl;
	}
	HANDLE hThread2 = (HANDLE)_beginthreadex(NULL, 0, ReadSharedData, 0, 0, &threadId);//创建读数据的线程
	if (hThread2 == NULL)
	{
		cout << "Starting ReadSharedData Thread  Failed!" << endl;
	}
	Sleep(1000000);//程序开始运行后1000s后自动关闭
	CloseFileMap();
	return 0;
}

两个程序初始运行界面：
在这里插入图片描述

程序A输入数据后，程序B自动显示出来，如下图：
在这里插入图片描述

程序B中输入数据，程序A中同步显示出来，如下图：
在这里插入图片描述

GreenHandBruce

关注

1
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
0
评论
c++共享内存（二）：通过两个共享内存地址块实现程序A和B的相互通信，并通过CreateSemaphore同步线程，防止程序A和B同时访问同一块内存块

在“c++共享内存（一）”中，我写了一个demo，实现了程序A接受到用户输入的字符串后存放到共享内存中，程序B收到用户输入任意字符的操作之后会从共享内存中读取该字符串并显示在控制台中。但这有个问题，如果程序A在放数据的同时，程序B就从该内存块中取数据，则必会发生冲突，引起程序崩溃。解决该问题的方法就是使用CreateSemaphore同步线程，防止程序A和B同时访问同一块内存块。程序A代码如...
复制链接

扫一扫