linux中进程之间通信

最新推荐文章于 2024-09-15 17:30:17 发布
原创 最新推荐文章于 2024-09-15 17:30:17 发布 · 334 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

关于linux进程通信有很多种类实现，比如管道，队列，共享内存。说一下自己的体会

管道：其实管道操作是很简单，只需要通过pipe()函数，返回一个两个句柄，一个用来输入，一个用来输出。

例子：

INT nPipeFds[2];

	if (pipe(nPipeFds) == -1)
	{
		return FALSE;
	}

但是这种匿名管道只能够用来操作具有继承关系的进程(fork())。如果没有继承关系的进程，我选择了使用共享内存，

说一下我的思路：

1.通信双方是单向的，相当主从关系。

2.从进程开一个线程，去读取共享内存数据。

3.当共享内存中消息缓冲区满了后，主进程就不能够去读了，直接返回。


相关代码如下：


#ifndef __PROCESSCOMM__H__20141226
#define __PROCESSCOMM__H__20141226

#include "Global.h"
#include "Thread.h"
#include "ProcessCrical.h"
#include <semaphore.h>

// 单向通道进程通信
class CWriteChannel
{
public:
	BOOL CreateChannel(const CHAR *lpszChannelName, INT nMaxChannelBufSize);
	BOOL WriteData(const CHAR *lpszData, INT nDataSize);
	VOID Close();

public:
	CWriteChannel();
	virtual ~CWriteChannel();

private:
	INT m_nWriteFd;
	BYTE *m_lpbyMapAddr;
	INT m_nChannelSize;
	CProcessCrical m_pCrical; // 文件锁
	sem_t *m_pSemt;

};

struct IChannelFunc
{
	virtual VOID OnReadChannel(const CHAR *lpszChannelData, INT nDataSize) = 0;
	DISALLOW_DESTRUCT(IChannelFunc)
};

class CReadChannel: public CThread
{
public:
	BOOL OpenChannel(const CHAR *lpszChannelName, IChannelFunc *lpFunc);
	VOID Close();

public:
	CReadChannel();
	virtual ~CReadChannel();

public:
	virtual BOOL OnCreateThread(VOID *lpContext);
	virtual VOID OnRun();

private:
	INT m_nReadFd;
	CProcessCrical m_pCrical;
	IChannelFunc *m_lpChannelFunc;
	BYTE *m_lpbyMapAddr;
	INT m_nChannelBufSize;
	BOOL m_bStop;
	sem_t *m_pSemt;
};

#endif

.cpp


#include "../Include/ProcessComm.h"
#include <sys/mman.h>
#include<fcntl.h>
#include <string.h>
#include <errno.h>

#pragma pack(1)
typedef struct tagMEM_SHARE_HEADER
{
	WORD wFront;
	WORD wBack;

}MEM_SHARE_HEADER; // 用来判定缓存区区域是否满,循环队列缓冲区
#pragma pack()

#define PAGE_SIZE (4096)
#define CHANNEL_CACHE_ADDR(lpbyMapAddr) (lpbyMapAddr + sizeof(MEM_SHARE_HEADER))
#define CHANNEL_CACHE_SIZE(nSize)	(nSize - sizeof(MEM_SHARE_HEADER))

#define CHANNEL_HEADER_ADDR(lpbyMapAddr) ((MEM_SHARE_HEADER *)lpbyMapAddr)

BOOL CWriteChannel::CreateChannel(const CHAR *lpszChannelName, INT nMaxChannelBufSize)
{
	ASSERT(lpszChannelName != NULL);
	MEM_SHARE_HEADER *pMemShareHeader;
	CHAR szShareName[100];
	BOOL bSucess;

	bSucess = FALSE;
	if (nMaxChannelBufSize <= 0)
	{
		goto Exit0;
	}

	m_nWriteFd = open(lpszChannelName, O_RDWR | O_TRUNC | O_CREAT, 0644);
	if (m_nWriteFd == -1)
	{
		goto Exit0;
	}

	// 创建文件锁
	sprintf(szShareName, "%s.lck", lpszChannelName);
	if (!m_pCrical.OpenProcessCrical(szShareName))
	{
		goto Exit0;
	}

	// 创建有名信号量，用来多进程同步
	sprintf(szShareName, "%s.sem", lpszChannelName);
	m_pSemt = sem_open(szShareName, O_CREAT | O_RDWR, 0644, 0);
	if (m_pSemt == SEM_FAILED)
	{
		goto Exit0;
	}

	// mmap申请映射
	m_nChannelSize = nMaxChannelBufSize / PAGE_SIZE * PAGE_SIZE;
	if (nMaxChannelBufSize % PAGE_SIZE)
	{
		m_nChannelSize += PAGE_SIZE;
	}
	lseek(m_nWriteFd, m_nChannelSize - 1, SEEK_SET);
	write(m_nWriteFd, "", 1); // 这一句千万不能够省略

	m_lpbyMapAddr = (BYTE *)mmap(NULL, m_nChannelSize, PROT_READ | PROT_WRITE, MAP_SHARED, m_nWriteFd, 0);
	if (m_lpbyMapAddr == (BYTE *)-1)
	{
		// 打印出出错信息
		goto Exit0;
	}

	pMemShareHeader = CHANNEL_HEADER_ADDR(m_lpbyMapAddr);
	pMemShareHeader->wBack = 0;
	pMemShareHeader->wFront = 0;

	munmap(m_lpbyMapAddr, m_nChannelSize);
	bSucess = TRUE;

Exit0:
	if (!bSucess)
	{
		if (m_nWriteFd != -1)
		{
			close(m_nWriteFd);
			m_nWriteFd = -1;
		}
		if (m_pSemt != SEM_FAILED)
		{
			sem_close(m_pSemt);
			m_pSemt = NULL;
		}
		m_pCrical.Close();
	}

	return bSucess;
}

BOOL CWriteChannel::WriteData(const CHAR *lpszData, INT nDataSize)
{
	MEM_SHARE_HEADER *pMemShareHeader;
	WORD wBackofQuque;
	BYTE *lpbyQuqueAddr;
	INT i,j;
	WORD wDataSize;

	wDataSize = nDataSize;
	m_pCrical.Lock();

	m_lpbyMapAddr 	= (BYTE *)mmap(NULL, m_nChannelSize, PROT_READ | PROT_WRITE, MAP_SHARED, m_nWriteFd, 0);
	pMemShareHeader = CHANNEL_HEADER_ADDR(m_lpbyMapAddr);
	wBackofQuque 	= (pMemShareHeader->wBack + 2 + nDataSize) % CHANNEL_CACHE_SIZE(m_nChannelSize);
	if ((wBackofQuque + 1) == pMemShareHeader->wFront)
	{
		// 缓冲区已满
		m_pCrical.UnLock();
		return FALSE;
	}

	lpbyQuqueAddr = CHANNEL_CACHE_ADDR(m_lpbyMapAddr);
	for (i = 0; i < 2; ++ i)
	{
		lpbyQuqueAddr[pMemShareHeader->wBack ++] = *((BYTE *)&wDataSize + i);
		pMemShareHeader->wBack %= CHANNEL_CACHE_SIZE(m_nChannelSize);
	}
	for (i = 0; i < nDataSize; ++ i)
	{
		lpbyQuqueAddr[pMemShareHeader->wBack ++] = lpszData[i];
		pMemShareHeader->wBack %= CHANNEL_CACHE_SIZE(m_nChannelSize);
	}

	munmap(m_lpbyMapAddr, m_nChannelSize);
	m_pCrical.UnLock();

	// 可以开始读数据了
	sem_post(m_pSemt);

	return TRUE;
}

VOID CWriteChannel::Close()
{

}

CWriteChannel::CWriteChannel()
{
	m_nWriteFd 		= -1;
	m_lpbyMapAddr 	= NULL;
	m_nChannelSize 	= -1;
	m_pSemt			= NULL;
}


CWriteChannel::~CWriteChannel()
{

}


BOOL CReadChannel::OpenChannel(const CHAR *lpszChannelName, IChannelFunc *lpFunc)
{
	CHAR szShareName[100];
	BOOL bSucess;

	bSucess = FALSE;

	// 创建文件锁
	sprintf(szShareName, "%s.lck", lpszChannelName);
	if (!m_pCrical.OpenProcessCrical(szShareName))
	{
		goto Exit0;
	}

	// 打开sem信号量
	sprintf(szShareName, "%s.sem", lpszChannelName);
	m_pSemt = sem_open(szShareName, O_RDWR);
	if (m_pSemt == NULL)
	{
		goto Exit0;
	}

	m_nReadFd = open(lpszChannelName, O_RDWR);
	if (m_nReadFd == -1)
	{
		goto Exit0;
	}

	m_bStop = FALSE;
	bSucess = TRUE;
	m_lpChannelFunc = lpFunc;
	m_nChannelBufSize = lseek(m_nReadFd, 0, SEEK_END);
	CThread::Start(NULL);

Exit0:
	if (!bSucess)
	{
		if (m_nReadFd != -1)
		{
			close(m_nReadFd);
			m_nReadFd = -1;
		}
		if (m_pSemt != NULL)
		{
			sem_close(m_pSemt);
			m_pSemt = NULL;
		}

		m_pCrical.Close();
	}

	return bSucess;
}

VOID CReadChannel::Close()
{

}


CReadChannel::CReadChannel()
{
	m_lpChannelFunc = NULL;
	m_lpbyMapAddr = NULL;
	m_bStop = TRUE;
	m_pSemt = NULL;
}

CReadChannel::~CReadChannel()
{

}

BOOL CReadChannel::OnCreateThread(VOID *lpContext)
{
	return TRUE;
}

VOID CReadChannel::OnRun()
{
	MEM_SHARE_HEADER *pMemShareHeader;
	WORD wBack;
	WORD wFront;
	INT nOffset;
	WORD wMsgLen;
	INT nMsgBytesNum;
	BYTE *lpbyDataAddr;
	CHAR szMsgBuf[1024];

	// 使用轮xun方法
	while (!m_bStop)
	{
		sem_wait(m_pSemt);

		m_pCrical.Lock();

		// mark，这里有个问题没有说明
		m_lpbyMapAddr 	= (BYTE *)mmap(m_lpbyMapAddr, m_nChannelBufSize, PROT_READ | PROT_WRITE, MAP_SHARED, m_nReadFd, 0);
		pMemShareHeader = CHANNEL_HEADER_ADDR(m_lpbyMapAddr);
		if (pMemShareHeader->wBack == pMemShareHeader->wFront) // 空
		{
			m_pCrical.UnLock();
			continue;
		}

		wBack = pMemShareHeader->wBack;
		wFront = pMemShareHeader->wFront;

		// 清空消息对列缓冲区
		pMemShareHeader->wBack = 0;
		pMemShareHeader->wFront = 0;
		msync(m_lpbyMapAddr, m_nChannelBufSize, MS_SYNC);

		m_pCrical.UnLock();

		// 开始解析消息
		lpbyDataAddr = CHANNEL_CACHE_ADDR(m_lpbyMapAddr);
		nOffset = 0;
		wMsgLen = 0;
		nMsgBytesNum = 0;
		while (wFront != wBack)
		{
			// 先读消息长度
			if (nMsgBytesNum < 2)
			{
				*((BYTE *)&wMsgLen + nMsgBytesNum) = lpbyDataAddr[wFront ++];
				nMsgBytesNum ++;
			}
			else
			{
				szMsgBuf[nOffset ++] = lpbyDataAddr[wFront ++];

				// 丢掉
				if (nOffset == 1024)
				{
					ASSERT(0);
				}
				if ((WORD)nOffset == wMsgLen)
				{
					// 回调上层
					m_lpChannelFunc->OnReadChannel(szMsgBuf, nOffset);
					nOffset = 0;
					wMsgLen = 0;
				}
			}

			wFront %= CHANNEL_CACHE_SIZE(m_nChannelBufSize);
		}

	}
}

说明一下：

1：因为是对同一文件进行操作，那么需要互斥，这里用到了文件写锁。可能加锁的时间过长，需要改进。

2.当初线程采取的轮循缓存区，这样感觉不太好，所有使用了有名信号量来通知。



进程间的通信
2401_83430041的博客
04-29 1374
进程间通信(IPC:Inter Processes Communication) 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源（例如打开的文件描述符）。进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信。在Linux下，要想查看这些信号和编码的对应关系，可使用命令：kill ­l。
Linux-进程间通信
AI_ELF的博客
08-23 7348
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
进程之间的通信
临水人亦静
08-28 986
1.共享储存器系统 （1）基于共享数据结构的通信方式：要求诸进程公用某些数据结构，借以实现诸进程之间的信息交换。传递数据少，效率低小，属于低级通信 （2）基于共享存储区的通信方式：为了传输大量数据，在内存中划出了一块共享存储区域，诸进程可通过对该共享区的读或写交换信息，实现通信，数据的形式和位置甚至访问控制都是由进程负责的，而不是OS。属于高级通信​（通信前需向系统申请或者共享区中的一个分区附
进程间通信
mz474920631的博客
03-04 1410
进程通信一、进程间通信介绍进程间通信的目的二、使用步骤1.引入库2.读入数据总结 一、进程间通信介绍 进程间通信的目的 数据传输：一个进程需要将它的数据发送给另一个进程 资源共享：多个进程之间共享同样的资源。 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。 要让两个进程通信，不需要让两个进程看到同一
实验四：Linux下进程管道通信.docx
04-13
**实验四：Linux下进程管道通信** 实验的目标是理解和掌握Linux操作系统中进程间通信的管道机制，通过系统调用pipe()实现数据交换。管道是一种特殊类型的文件，它允许相关进程之间进行单向通信。在这个实验中，我们...
Linux进程间通信方式之socket使用实例
09-15
本文详细介绍了Linux环境中使用套接字进行进程间通信的基本原理和实践方法。通过具体的代码示例，读者可以了解到如何创建、绑定、监听和接受客户端连接等关键步骤。此外，文章还简要提到了其他类型的套接字及其应用...
实验 Linux进程通信的参考答案
07-05
Linux 进程通信是指在操作系统中，多个进程之间进行数据交换和同步的机制。在 Linux 中，进程通信可以通过信号、管道和共享内存等方式实现。 一、信号机制 在 Linux 中，信号是一种异步通信机制，允许一个进程向另...
嵌入式系统/ARM技术中的linux下的进程通信
11-10
在嵌入式系统和ARM技术领域，Linux操作系统提供了一套丰富的进程通信机制，这些机制源自Unix平台，并在Linux中得到进一步发展。进程通信是多进程系统中不同进程间交换信息和协调工作的重要手段。主要分为以下几类： ...
两个程序进程之间的通信
08-24
两个程序进程之间的通信 里面有进程间通信的各种方式的见解, 并有一些代码例子
进程间的通信方式
qq_44041062的博客
08-01 179
如果多个进程之间需要协同处理某个任务时，这时就需要进程间的同步和数据交流。常用的进程间通信（IPC，InterProcess Communication）的方法有： 1. 信号 ( Sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生； 像在我之间写的mqtt博客中就使用到了信号函数。 2. 管道（Pipe）：管道是一种半双工的通信方式，数据只能单向流动，而且只能在...
＜Linux＞ 进程间通信
最新发布
prodigy623的博客
09-15 2746
进程间通信，匿名管道、命名管道、共享内存、消息队列、信号量
【Linux】进程间通信
热门推荐
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
进程间通信方式
记录各种Bug解决案例及日常学习内容
08-04 730
管道：速度慢，容量有限，只有父子进程能通讯；FIFO：任何进程间都能通讯，但速度慢；消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题；共享内存：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题；信号：有入门版和高级版两种，区别在于入门版注重动作，高级版可以传递消息。只有在父子进程或者是共享内存中，才可以发送字符串消息；信号量：不能传递复杂消息，只能用来同步。......
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值