• C/C++使用Windows的API实现共享内存以及同步

    目录

    共享内存

    共享内存指 (shared memory)在多处理器的计算机系统中，可以被不同中央处理器（CPU）访问的大容量内存。由于多个CPU需要快速访问存储器，这样就要对存储器进行缓存（Cache）。任何一个缓存的数据被更新后，由于其他处理器也可能要存取，共享内存就需要立即更新，否则不同的处理器可能用到不同的数据。共享内存是 Unix下的多进程之间的通信方法 ,这种方法通常用于一个程序的多进程间通信，实际上多个程序间也可以通过共享内存来传递信息。

    事件-Event

    Win 中最具弹性的同步机制就属 events 对象了。 Event 对象是一种核心对象，它的唯一目的就是成为激发状态或未激发状态。这两种状态全由程序来控制，不会成为 WaitForSingleObject() 函数的副作用。
    Event 对象之所以有大用途，正是因为它们的状态完全在你掌控之下。Mutexes和semaphores就不一样了，它们的状态会因为诸如WaitForSingleObject() 之类的函数调用而变化。所以， 你可以精确告诉一个event 对象做什么事，以及什么时候去做。

    实现思路

    创建方(服务端)

    1. 首先创建共享内存CreateFileMapping(映射文件句柄，安全属性，访问权限，对象大小，共享内存大小，映射文件名)；（注意：映射文件名双方必须一致）
    2. 再将共享内存地址映射到本进程中MapViewOfFile(共享内存地址，访问权限，文件映射起始偏移的高32位，文件映射起始偏移的低32位， 映射文件的字节数.)
    3. 然后创建事件CreateEventW用于俩个进程间的同步，

    连接方：

    1. 首先创建共享内存CreateFileMapping(映射文件句柄，安全属性，访问权限，对象大小，共享内存大小，映射文件名)；（注意：映射文件名双方必须一致）
    2. 再将共享内存地址映射到本进程中MapViewOfFile(共享内存地址，访问权限，文件映射起始偏移的高32位，文件映射起始偏移的低32位， 映射文件的字节数.)
    3. 然后创建同样数量的事件CreateEventW(此时的事件名称要与另一方一致)。这样在创建事件时系统就会发现这个事件已经被另一方创建过，就直接将创建好的句柄返回来。才可实现进程同步

    进程同步：

    例如 现有俩个事件g_EventRead和g_EventWrite；
    初始状态g_EventRead和g_EventWrite事件的信号灯都是灭的。先启动创建方，然后启动连接方时，在初始化时将创建方的EventWrite事件的信号灯点亮，这样创建方获得数据就可以直接写入共享内存中并将g_EventRead灯点亮将g_EventWrite灯弄灭。然后连接方收到数据就可以读取共享内存中的数据，再将g_EventRead灯弄灭将g_EventWrite灯点亮。这样就实现了进程间的通讯。

    windows的API

    CreateFileMapping

    创建共享内存

    HANDLE WINAPI CreateFileMapping(
_In_HANDLE hFile,
_In_opt_LPSECURITY_ATTRIBUTES lpAttributes,
_In_DWORD flProtect,
_In_DWORD dwMaximumSizeHigh,
_In_DWORD dwMaximumSizeLow,
_In_opt_LPCTSTR lpName);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    参数：

    1. _In_HANDLE 映射文件的句柄 NVALID_HANDLE_VALUE则创建一个进程间共享的对象
    2. _In_opt_LPSECURITY_ATTRIBUTES 安全属性
    3. _In_DWORD 保护方式
    4. _In_DWORD 对象的大小, 32位.
    5. _In_DWORD 共享内存大小 字节
    6. _In_opt_LPCTSTR 映射文件名，即共享内存的名称

    MapViewOfFile

    将共享内存映射到本地进程

    LPVOID WINAPI MapViewOfFile(
__in HANDLE hFileMappingObject,
__in DWORD dwDesiredAccess,
__in DWORD dwFileOffsetHigh,
__in DWORD dwFileOffsetLow,
__in SIZE_T dwNumberOfBytesToMap
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    参数：

    1. hFileMappingObject 为CreateFileMapping()或OpenFileMapping()返回的文件映像对象句柄。
    2. dwDesiredAccess 映射对象的文件数据的访问方式，而且同样要与CreateFileMapping()函数所设置的保护属性相匹配。 可取以下值：
      1. FILE_MAP_ALL_ACCESS 等价于CreateFileMapping的 FILE_MAP_WRITE|FILE_MAP_READ. 文件映射对象被创建时必须指定PAGE_READWRITE 选项.
      2. FILE_MAP_COPY 可以读取和写入文件.写入操作会导致系统为该页面创建一份副本.在调用CreateFileMapping时必须传入PAGE_WRITECOPY保护属性.
      3. FILE_MAP_EXECUTE 可以将文件中的数据作为代码来执行.在调用CreateFileMapping时可以传入PAGE_EXECUTE_READWRITE或PAGE_EXECUTE_READ保护属性.
      4. FILE_MAP_READ 可以读取文件.在调用CreateFileMapping时可以传入PAGE_READONLY或PAGE_READWRITE保护属性.
      5. FILE_MAP_WRITE 可以读取和写入文件.在调用CreateFileMapping时必须传入PAGE_READWRITE保护属性.
    3. dwFileOffsetHigh 表示文件映射起始偏移的高32位.
    4. dwFileOffsetLow 表示文件映射起始偏移的低32位.(64KB对齐不是必须的)
    5. dwNumberOfBytes 指定映射文件的字节数.

    CreateEvent

    创建事件

    HANDLE CreateEvent(
LPSECURITY_ATTRIBUTESlpEventAttributes,// 安全属性
BOOLbManualReset,// 复位方式
BOOLbInitialState,// 初始状态
LPCTSTRlpName // 对象名称
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    参数：
    1. 安全属性 默认为NULL
    2. 复位方式 (true-手工恢复， false-自动恢复)
    3. 初始状态 (true-有信号，false-无信号)
    4. 事件名称
    返回值：

    1. 事件的句柄

    WaitForSingleObject

    在指定时间内等待事件的信号状态

    DWORD WaitForSingleObject(

HANDLE hHandle,
DWORD dwMilliseconds
);

    • 1
    • 2
    • 3
    • 4
    • 5

    参数：

    1. hHandle 对象句柄。可以指定一系列的对象，如Event、Job、Memory resource notification、Mutex、Process、Semaphore、Thread、Waitable timer等。
    2. dwMilliseconds 定时时间间隔，单位为milliseconds（毫秒）

    CreateThread

    创建一个线程

    HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,//SD
SIZE_T dwStackSize,//initialstacksize
LPTHREAD_START_ROUTINE lpStartAddress,//threadfunction
LPVOID lpParameter,//threadargument
DWORD dwCreationFlags,//creationoption
LPDWORD lpThreadId//threadidentifier
)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    参数：

    1. lpThreadAttributes 指向SECURITY_ATTRIBUTES型态的结构的指针。在Windows 98中忽略该参数。在Windows NT中，NULL使用默认安全性，不可以被子线程继承，否则需要定义一个结构体将它的bInheritHandle成员初始化为TRUE
    2. dwStackSize，设置初始栈的大小，以字节为单位，如果为0，那么默认将使用与调用该函数的线程相同的栈空间大小。任何情况下，Windows根据需要动态延长堆栈的大小。
    3. lpStartAddress，指向线程函数的指针，形式：@函数名，函数名称没有限制，
    4. lpParameter：向线程函数传递的参数，是一个指向结构的指针，不需传递参数时，为NULL。
    5. dwCreationFlags ：线程标志,可取值如下
      （1）CREATE_SUSPENDED(0x00000004)：创建一个挂起的线程，
      （2）0：表示创建后立即激活。
      （3）STACK_SIZE_PARAM_IS_A_RESERVATION(0x00010000)：dwStackSize参数指定初始的保留堆栈 的大小，否则,dwStackSize指定提交的大小。
    6. lpThreadId:保存新线程的id。

    OpenFileMapping

    打开一个现成的文件映射对象的函数

    HANDLE WINAPI OpenFileMapping(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL bInheritHandle,
    _In_ LPCWSTR lpName
    )

    • 1
    • 2
    • 3
    • 4
    • 5

    参数：

    1. dwDesiredAccess 访问方式
    2. bInheritHandle 继承标志句柄继承选项表示内核对象被子进程继承
    3. lpName 指定要打开的文件映射对象名称。

    通过共享内存实现进程间的交互

    服务端

    #include 
#include  
using namespace std;

#define BUF_SIZE 4096

HANDLE g_EventRead;		// 读信号灯
HANDLE g_EventWrite;	// 写信号灯
// 定义共享数据
char szBuffer[] = "LinXi07";
/* 读取con1串口的线程 */
DWORD __stdcall WriteThread(const LPVOID lp)
{
	while (true)
	{
		WaitForSingleObject(g_EventWrite, INFINITE); // 等待读数据的信号

		// 将数据拷贝到共享内存
		strcpy((char*)lp, szBuffer);
		cout << "服务发送成功!等待客户端接受：" << (char*)lp << endl;
		
		Sleep(1000);
		
		SetEvent(g_EventRead);
		ResetEvent(g_EventWrite);
	}
	return DWORD();
}

int main()
{

	// 创建共享文件句柄 
	HANDLE hMapFile = CreateFileMapping(
		INVALID_HANDLE_VALUE,   // 物理文件句柄  NVALID_HANDLE_VALUE  则创建一个进程间共享的对象
		NULL,   // 默认安全级别
		PAGE_READWRITE,   // 可读可写
		0,   // 高位文件大小
		BUF_SIZE,   // 低位文件大小
		L"ShareMemoryPDU"   // 映射文件名，即共享内存的名称
	);

	if (0 == hMapFile)
	{
		return 0;
	}

	// 映射缓存区视图 , 得到指向共享内存的指针
	// 将hFileMapping共享内存衍射到本进程的地址空间中
	LPVOID lpBase = MapViewOfFile(
		hMapFile,            // 共享内存的句柄
		FILE_MAP_ALL_ACCESS, // 可读写许可
		0,
		0,
		BUF_SIZE
	);

	if (0 == lpBase)
	{
		return 0;
	}

	g_EventRead = CreateEventW(NULL, TRUE, FALSE, TEXT("EventRead"));
	if (nullptr == g_EventRead)
	{
		return 0;
	}

	g_EventWrite = CreateEventW(NULL, TRUE, TRUE, TEXT("EventWrite"));
	if (nullptr == g_EventRead)
	{
		return 0;
	}

	HANDLE handle = CreateThread(NULL, 0, WriteThread, lpBase, 0, NULL);

	WaitForSingleObject(handle, INFINITE);
	
	// 解除文件映射
	UnmapViewOfFile(lpBase);
	
	// 关闭内存映射文件对象句柄
	CloseHandle(hMapFile);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85

    客户端

    #include   
#include   
#include 
using namespace std;

#define BUF_SIZE 4096

HANDLE g_EventRead;		// 读信号灯
HANDLE g_EventWrite;	// 写信号灯


DWORD __stdcall ReadThread(const LPVOID lp)
{
	while (true)
	{
		WaitForSingleObject(g_EventRead, INFINITE); // 等待读数据的信号
	// 将数据拷贝到共享内存

	// 将共享内存数据拷贝出来
		char szBuffer[BUF_SIZE]{ 0 };
		
		strcpy_s(szBuffer, (char*)lp);
		
		std::cout << "客户数据读取成功！：" << szBuffer << endl;

		ResetEvent(g_EventRead); /* 将读取信号关闭  */
		SetEvent(g_EventWrite);
	}
}

int main()
{
	// 打开共享的文件对象
	HANDLE hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, NULL, L"ShareMemoryPDU");

	if (0 == hMapFile)
	{
		// 打开共享内存句柄失败
		std::cout << "打开共享失败！" << endl;
		return 0;
	}
	LPVOID lpBase = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 0);
	if (0 == lpBase)
	{
		return 0;
	}

	g_EventRead = CreateEventW(NULL, TRUE, FALSE, TEXT("EventRead"));
	if (nullptr == g_EventRead)
	{
		return 0;
	}

	g_EventWrite = CreateEventW(NULL, TRUE, TRUE, TEXT("EventWrite"));
	if (nullptr == g_EventRead)
	{
		return 0;
	}

	HANDLE handle = CreateThread(NULL, 0, ReadThread, lpBase, 0, NULL);
	if (0 == handle)
	{
		return 0;
	}
	
	WaitForSingleObject(handle, INFINITE);
	// 解除文件映射
	
	UnmapViewOfFile(lpBase);
	// 关闭内存映射文件对象句柄
	CloseHandle(hMapFile);


	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75

    结论

    单启动服务端，将只会发出一条，然后就一直处于等待状态
    在这里插入图片描述

    先启动服务端，再启动客户端。可以看到俩进程之间进行数据共享
    在这里插入图片描述

  • 相关阅读:
    鸿蒙应用开发之打包与上架
    使用编码工具
    jQuery常用API--样式操作
    Mysql主从集群同步延迟问题怎么解决
    网络编程、OSI七层协议
    元数据管理-解决方案调研二：元数据管理解决方案——早期传统解决方案
    按照前序输入创建二叉树并以前序遍历二叉树
    【PyTorch】深度学习实践之 RNN基础篇——实现RNN
    面向对象分析与设计好文章
    低代码助力生产管理：车间管理系统
  • 原文地址：https://blog.csdn.net/qq_45254369/article/details/128152170