共享内存+互斥量实现 Linux 进程间通信

一、共享内存简介

共享内存是进程间通信中高效方便的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针，两个进程可以对一块共享内存进行读写。

共享内存并未提供进程同步机制，使用共享内存完成进程间通信时，需要借助互斥量或者信号量来完成进程的同步。这里说一下互斥量与信号量的区别。互斥量用于线程的互斥，信号量用于线程的同步，这是互斥量与信号量的本质区别，其次信号量实现互斥量的功能。

本文结合个人实际项目需求，采用互斥量实现进程间访问共享内存的互斥，即同一时刻只能允许一个进程对共享内存进行写操作，当然也可以用信号量来完成进程间的互斥，这里就不再赘述。

二、使用系统调用完成共享内存的申请、连接、分离和删除

共享内存函数由shmget、shmat、shmdt、shmctl四个函数组成。使用时需要包含#include <sys/ipc.h>、#include <sys/shm.h>、#include <sys/types.h>和。

1.共享内存的申请

使用shmget()完成共享内存的申请，函数原型如下：

int shmget(key_t key, size_t size, int shmflg);

key：共享内存的标识符，大于0的32位整数。若是父子关系的进程间通信，这个标识符用IPC_PRIVATE，若进程没有关系，可自行定义。

size：共享内存大小，单位Byte。

shmflg：共享内存的模式(mode)，包括三部分，第一部分是：无指定标示符的共享内存是否创建，由

0（只获取）或IPC_CREAT（未创建则新建）决定。第二部分：IPC_EXCL（若已创建，则报错）。第三部分：权限标识，由八进制表示，如0640，第一个0是八进制数标识，第一个6（4+2）表示拥有者的权限读和写，第二个4表示同组权限写，第3个0表示他人的权限。这三部分由算数或运算符|拼接组成shmflg，如IPC_CREAT|0640。

成功时返回共享内存的ID，失败时返回-1。

2.共享内存的连接

使用shmat()函数将已经申请好的共享连接到当前进程的地址空间，函数原型如下：

void *shmat(int shmid, const void *shmaddr, int shmflg);

shmid：共享内存标识符。

shmaddr：指定共享内存连接到进程地址空间的位置，直接指定为NULL让内核自己决定一个合适的地址位置。

shmflg：SHM_RDONLY为只读模式，其他为读写模式，通常设置为NULL。

成功时，这个函数返回共享内存的起始地址。失败时返回-1。

3.共享内存的分离

使用sdmdt()函数将已连接的共享内存与进程分离，功能与shmat()相反，函数原型如下：

int shmdt(const void *shmaddr);

shmaddr: 连接的共享内存的起始地址。成功时返回0。失败时返回-1。

4.共享内存的删除

shmctl() 控制对这块共享内存的使用，包括删除。函数原型如下：

int shmctl(int shmid, int command, struct shmid_ds *buf);

shmid：共享内存的ID。

command：是控制命令，IPC_STAT（获取共享内存的状态）、IPC_SET（改变共享内存的状态）IPC_RMID（删除共享内存）。

buf：一个结构体指针。Command设置为IPC_STAT的时候，取得的状态放在这个结构体中。如果要改变共享内存的状态，由这个结构体指定。

返回值：成功：0，失败：-1。

三、使用互斥量完成父子进程对共享内存的互斥访问

在共享内存中申明互斥量pthread_mutex_t mutex，需要包含<pthread.h>头文件。使用时的步骤是：

第一步：初始化互斥量，使用pthread_mutex_init()函数，函数原型如下：

intpthread_mutex_init(pthread_mutex_t*restrict mutex,constpthread_mutexattr_t *restrict attr);

使用方法：pthread_mutex_init(&mutex,NULL)。函数成功返回0，失败返回非0。

第二步：对互斥量进程上锁，使用pthread_mutex_lock()函数，函数原型如下：

int pthread_mutex_lock(pthread_mutex_t *mutex);

函数成功返回0，错误返回非0的错误代码。

第三步：pthread_mutex_unlock()对已经上锁的mutex进行解锁，pthread_mutex_lock()成对出现，函数原型如下：

int pthread_mutex_unlock(pthread_mutex_t*mutex)。

函数成功返回0，错误返回非0的错误代码。

第四步：如果最后不需要使用互斥量的话，使用pthread_mutex_destroy()销毁。函数原型如下：

int pthread_mutex_destroy(pthread_mutex_t*mutex);

函数成功返回0，错误返回非0的错误代号。

四、示例源码

鄙人以实际项目开发过程中实现进程间通信的源码，为大家展示如何利用上面总结的系统调用接口

来实现进程间的通信。

1. 定义存储成员变量的类，共享内存将用于存放该类的成员数据。

<pre name="code" class="cpp"><pre name="code" class="cpp">class ALGOriginalTask
{
public:uint8 algorithm;   //算法，在global.h中定义
uint8 encodeType;  //编码类型0：UTF8，1：UCS2uint32 cipher_num;      //密文数目uint32 cipher_len;   //密文长度char cipher[128][256];  //密文最多128个uint8 salt_len;  //盐的长度char salt[128][32];//最多128个，最长32字节char re[32][256];
uint8 plainfile_num;
pthread_mutex_t mutex;//读写共享内存互斥量
};
class ALGResult
{
public:bool init();ALGResult() {};~ALGResult() {};struct timeval ts;struct timeval te;uint8  success_num;uint8 algorithm;uint8 cipher_len;char cipher[128][256]; char salt[128][32];char ret_plain[MAX_CIPHER_NUM][MAX_PLAIN_LEN];
};

2. 使用fork()在父进程中产生子进程，通过系统调用execve()调用另外可执行程序ALG.out,将ALGOriginalTask中的数据写入共享内存后，再在ALG.out中通过接收到的shmid获取共享内存进行读取。最后在ALG.out中将ALGResult中的数据写入共享内存，再由父进程读取结果。

父进程代码：

int main(int argc, char **argv)
{
pid_t pid;//子进程IDint shmid;//共享内存IDALGOriginalTask* ALG_shm_addr=NULL;ALGResult* ALG_Result_shm_addr=NULL;void* shm_addr=NULL;//共享内存首地址//char buff[sizeof(ALGOriginalTask)];if ((shmid=shmget(IPC_PRIVATE,sizeof(ALGOriginalTask)+sizeof(ALGResult),IPC_CREAT|0640))<0)//创建当前进程的父子进程私有共享内存{perror("shmget");exit(-1);} else{//create successfullyprintf("Create shared memory: %d.\n",shmid);printf("Created shared memory status:\n");system("ipcs -m");}printf("start fork\n");switch(pid=fork()){case -1:perror("fork");exit(-1);case 0://child{//构造ALG.out参数string shmId=itoa(shmid);string plain_path=ALG_task->plainfile_path;string plain_offset=itoa(ALG_task->plain_offset);string plain_num=itoa(ALG_task->plain_num);string plain_len=itoa(ALG_task->plain_len);cout<<"start execute ALG.out"<<endl;const char* argv[10]={"./ALG.out",shmId.c_str(),plain_path.c_str(),plain_offset.c_str(),plain_num.c_str(),plain_len.c_str()};execlp(argv[0], argv[0], argv[1], argv[2], argv[3],argv[4], argv[5], NULL);exit(0);}default://parent{if((shm_addr=shmat(shmid,0,0))==(void*)-1){perror("Parent:shmat");//打印函数执行错误原因,Parent:shmat:错误原因exit(-1);}else{//初始化共享内存memset(shm_addr,NULL,sizeof(ALGOriginalTask)+sizeof(ALGResult));printf("Parent: Attach shared-memory: %p\n",shm_addr);printf("Parent Attach shared memory status:\n");system("ipcs -m");}//设置共享内存格式ALG_shm_addr=static_cast<ALGOriginalTask*>(shm_addr);//向共享内存写入参数pthread_mutex_init(&ALG_shm_addr->mutex,NULL); pthread_mutex_lock(&ALG_shm_addr->mutex);//初始化originalTask       cout<<"writeALG_original_task->algorithm:"<<(int)ALG_original_task->algorithm<<endl;ALG_shm_addr->algorithm=ALG_original_task->algorithm;ALG_shm_addr->encodeType=ALG_original_task->encodeType;ALG_shm_addr->cipher_num=ALG_original_task->cipher_num;ALG_shm_addr->cipher_len=ALG_original_task->cipher_len;ALG_shm_addr->salt_len=ALG_original_task->salt_len;//memcpy(ALG_shm_addr->task_name,ALG_original_task->task_name,20);memcpy(ALG_shm_addr->cipher,ALG_original_task->cipher,128*256);memcpy(ALG_shm_addr->salt,ALG_original_task->salt,128*32);memcpy(ALG_shm_addr->re,ALG_original_task->re,32*256);pthread_mutex_unlock(&ALG_shm_addr->mutex);waitpid(pid,NULL,0);//等待子进程计算结束，从共享内存读取返回结果ALG_Result_shm_addr=static_cast<ALGResult*>(shm_addr);//设置共享内存格式//读取共享内存数据，即计算结果memcpy(&ALG_Result->ts,&ALG_Result_shm_addr->ts,sizeof(struct timeval));memcpy(&ALG_Result->te,&ALG_Result_shm_addr->te,sizeof(struct timeval));ALG_Result->success_num=ALG_Result_shm_addr->success_num;memcpy(ALG_Result->ret_plain,ALG_Result_shm_addr->ret_plain,128*64);//删除父进程的共享内存映射地址if (shmdt(shm_addr)<0) {perror("Parent:shmdt");exit(1);}elseprintf("Parent: Deattach shared-memory.\n");//删除共享内存if (shmctl(shmid,IPC_RMID,NULL)==-1){perror("shmct:IPC_RMID");exit(-1);}elseprintf("Delete shared-memory.\n");}}//end forkALG_Result->algorithm=ALG_original_task->algorithm;memcpy(ALG_Result->cipher,ALG_original_task->cipher,128*256);memcpy(ALG_Result->salt,ALG_original_task->salt,128*32);cout<<"computation end"<<endl;//succeedreturn ALG_Result;
}<strong>
</strong>

ALG.out代码：

int main(int argc, char **argv)
{gettimeofday(&tt1,NULL);ALGOriginalTask* ALG_shm_addr=NULL;ALGResult* ALG_Result_shm_addr=NULL;GPR_Info* gpr_Info=new GPR_Info;RST_Info* rst_Info=new RST_Info;memset(gpr_Info,NULL,sizeof(GPR_Info));memset(rst_Info,NULL,sizeof(RST_Info));void* shm_addr=NULL;//共享内存首地址int shmid=atoi(argv[1]);if((shm_addr=shmat(shmid,0,0))==(void*)-1){perror("Child_ALG.out:shmat");exit(-1);}//设置共享内存格式ALG_shm_addr=static_cast<ALGOriginalTask*>(shm_addr);//waiting for the parent write data to share memorycout<<"wait parent write sharememory:"<<endl;while(1){if((int)ALG_shm_addr->algorithm>=0)break;}cout<<"start read gpr_Info from sharememory:"<<endl;//get info of GPRpthread_mutex_lock(&ALG_shm_addr->mutex);//lock waiting for parent process finish the writing of share memorygpr_Info->algorithm=ALG_shm_addr->algorithm;gpr_Info->encodeType=ALG_shm_addr->encodeType;gpr_Info->cipher_num=ALG_shm_addr->cipher_num;gpr_Info->cipher_len=ALG_shm_addr->cipher_len;gpr_Info->plain_len=atoi(argv[5]);gpr_Info->salt_len=ALG_shm_addr->salt_len;memcpy(gpr_Info->salt,ALG_shm_addr->salt,128*32);memcpy(gpr_Info->cipher,ALG_shm_addr->cipher,128*256);pthread_mutex_unlock(&ALG_shm_addr->mutex);//unlock the mutex//获取计算结果get_ret_palin(ret_plain, gpr_Info);
//write result to share memory
memset(shm_addr,NULL,sizeof(ALGOriginalTask)+sizeof(ALGResult));ALG_Result_shm_addr=static_cast<ALGResult*>(shm_addr);ALG_Result_shm_addr->ts=tt1;ALG_Result_shm_addr->te=tt2;ALG_Result_shm_addr->algorithm=gpr_Info->algorithm; ALG_Result_shm_addr->cipher_len=gpr_Info->cipher_len;ALG_Result_shm_addr->success_num=rst_Info->success_num;memcpy(ALG_Result_shm_addr->salt,gpr_Info->salt,128*32);memcpy(ALG_Result_shm_addr->cipher,gpr_Info->cipher,128*256);memcpy(ALG_Result_shm_addr->ret_plain,ret_plain,128*64); //删除子进程的共享内存映射地址if (shmdt(shm_addr)<0)
{perror("ALG.out:shmdt");exit(1);}elseprintf("ALG.out:Detach shared-memory.\n");        delete []charset;delete []ret_plain;return 1;
}

参考文献：

[1]百度百科.共享内存

[2] http://blog.csdn.net/ljianhui/article/details/10253345

[3]Unix环境高级编程第三版

共享内存+互斥量实现 Linux 进程间通信相关推荐

linux 共享内存_盘点那些linux 后台开发类常见问题及知识点
一.linux和os: netstat :显示网络状态 tcpdump:主要是截获通过本机网络接口的数据,用以分析.能够截获当前所有通过本机网卡的数据包.它拥有灵活的过滤机制,可以确保得到想要的数据. ...
Linux下进程间通信--共享内存：最快的进程间通信方式
内存共享最新整理: Linux下进程间通信-共享内存 - 码到城攻共享内存可以说是最有用的进程间通信方式,也是最快的IPC形式https://www.codecomeon.com/posts/109/ ...
linux获取共享内存失败2,unix/linux共享内存应用与陷阱
共享内存是系统出于多个进程之间通讯的考虑,而预留的的一块内存区.在/proc/sys/kernel/目录下,记录着共享内存的一些限制,如一个共享内存区的最大字节数shmmax,系统范围内最大共享内存 ...
linux共享内存变量 tiaojianbianliang,修改linux共享内存大小
这是实际linux系统显示的实际数据: beijibing@bjb-desktop:/proc/sys/kernel$ cat shmmax 33554432 beijibing@bjb-deskto ...
Linux共享内存二维数组,linux系统编程--shmget shmat shmdt
要使用共享内存,应该有如下步骤: 1.开辟一块共享内存 shmget() 2.允许本进程使用共某块共享内存 shmat() 3.写入/读出 4.禁止本进程使用这块共享内存 shmdt() 5.删除这块 ...
linux 进程原理内存,linux进程通信之共享内存原理（基于linux 1.2.13）
1 有一个全局的结构体数据,每次需要一块共享的内存时(shmget),从里面取一个结构体,记录相关的信息. struct shmid_ds { // 权限相关 struct ipc_perm shm_ ...
linux共享内存的定义,共享内存是什么意思 Linux系统如何共享内存
共享内存概念共享内存是通信效率最高的IPC方式,因为进程可以直接读写内存,而无需进行数据的拷备.但是它没有自带同步机制,需要配合信号量等方式来进行同步. 共享内存被创建以后,同一块物理内存被映射到了 ...
mysql数据库映射到内存_基于共享内存的数据库映射
基于共享内存的数据库映射概述随着各类行业软件对性能追求越来越高,因此对数据库处理的速度提出了新的挑战.然而大部分复杂的业务处理往往依赖体量较大的关系数据(如:Oracle,Mysql,Postgr ...
Linux——进程间通信（共享内存【mmap实现+系统V】）
共享内存共享内存可以说是最有用的进程间通信方式,也是最快的IPC形式,两个不同的进程A.B共享内存的意思就是:同一块物理内存被映射到进程A.B各自的进程地址空间,进程A可以同时看到进程B对共享内存中 ...

共享内存+互斥量实现 Linux 进程间通信

共享内存+互斥量实现 Linux 进程间通信相关推荐

最新文章

热门文章