linux 进程间通信使用共享内存

共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。

shmget函数原型

两个进程，一个读进程，一个写进程。进程间通过信号量来保持同步，进程间数据传送使用共享内存。

首先启动写进程，设置共享内存，设置信号量，并向共享内存写入数据。之后释放信号量。读进程启动链接共享内存，获得信号量，读取共享内存内容，之后释放信号量。

写进程内容

#include <stdlib.h>
#include <stdio.h>
#include <sys/shm.h>
#include <string.h>
#include <unistd.h>
#include <sys/sem.h>
#include "Ccommon.h"
union semun
{
 int val;
 struct semid_ds *buf;
 unsigned short *array;
};
//初始化信号量
static int set_semvalue(void);
//删除信号量
static void del_semvalue(void);
//获得信号量
static int semaphore_p(void);
//释放信号量
static int semaphore_v(void);
static int sem_id;
int main()
{
  bool isRuning = true;
  void *pMem = NULL;
  struct shared_use_str *pshared_use_str;
  char buffer[BUFSIZ];
  int ishmid;
                   
  //创建信号量
   sem_id = semget((key_t)1234,1,0666|IPC_CREAT);
  //创建共享内存
 ishmid = shmget((key_t)1234,sizeof(struct shared_use_str),0666|IPC_CREAT );
                   
   //初始化信号量
   if(!set_semvalue())
   {
     fprintf(stderr,"Failed to initialize semaphore\n");
     exit(-1);
   } 
                    
  if(-1 == ishmid)
  {
      printf("shmid failed\n");
      exit(-1);
  }
  //得到共享内存
  pMem = shmat(ishmid,(void *)0,0);
  if(pMem == (void *)-1)
  {
    printf("shmat failed\n");
    exit(-1);
  }
                   
  printf("Memory Attached at %X\n",pMem);
  //将结构体指针指向共享内存
  pshared_use_str = (struct shared_use_str *) pMem;
                   
  while(true == isRuning)
  {
      //获得排它锁
   if(!semaphore_p())
   {
     printf("semp p failed\n");
     exit(-1);
   }
                      
     printf("enter some text\n");
     fgets(buffer,BUFSIZ,stdin);
                      
//修改共享内存的内容     strncpy(pshared_use_str->somedate,buffer,TEXT_SIZE);
     pshared_use_str->iwrite_by_you = 1;
     if(strncmp(buffer,"end",3) == 0)
     {
       isRuning = 0;
    } 
                     
    //释放排它锁
   if(!semaphore_v())
   {
     printf("failed to set v \n");
     exit(-1);
   } 
  } 
                   
  //等待读进程信号量结束
   sleep(3);
     //删除信号量
   del_semvalue();
   //解除共享内存
  if(shmdt(pMem) == -1)
  {
    printf("shmdt failed\n");
    return -1;
  } 
                   
  return 0;
}
static int set_semvalue(void)
{
 union semun sem_unition;
 sem_unition.val = 1;
 //初始化信号量，设置信号量值为1
 if(semctl(sem_id,0,SETVAL,sem_unition) == -1)
 {
   printf("faile to semctl\n");
   return -1;
 } 
 return 1;
}
static void del_semvalue(void )
{
 union semun sem_unition;
 //删除信号量
 if(semctl(sem_id,0,IPC_RMID,sem_unition) == -1)
 {
   printf("failed to semctl\n");
   return;
 } 
}
static int semaphore_p(void )
{
 struct sembuf sem_b;
 sem_b.sem_num = 0;
 sem_b.sem_op = -1;
 sem_b.sem_flg = SEM_UNDO;
//获得信号量 ，并进行减1操作，信号量为0之后挂起。禁止其它进程访问
if(-1 == semop(sem_id,&sem_b,1))
 {
   printf("semaphore failed\n");
   return 0;
 } 
 return 1;
}
static int semaphore_v(void )
{
 struct sembuf sem_b;
 sem_b.sem_num = 0;
 sem_b.sem_op = 1;
 sem_b.sem_flg = SEM_UNDO;
//释放信号量 ，并进行加1操作，信号量大于0之后执行。其它进程可以访问
 if(-1 == semop(sem_id,&sem_b,1))
 {
   printf("semaphore failed\n");
   return 0;
 } 
 return 1;
}

读者进程

#include <stdlib.h>
#include <stdio.h>
#include <sys/shm.h>
#include <string.h>
#include <unistd.h>
#include "Ccommon.h"
#include <sys/sem.h>
union semun
{
 int val;
 struct semid_ds *buf;
 unsigned short *array;
};
//初始化信号量
static int set_semvalue(void);
//删除信号量
static void del_semvalue(void);
//获得信号量
static int semaphore_p(void);
//释放信号量
static int semaphore_v(void);
static int sem_id;
int main()
{
  bool isRuning = true;
  void *pMem = NULL;
  struct shared_use_str *pshared_use_str;
  int ishmid;
    
    //创建信号量
   sem_id = semget((key_t)1234,1,0666|IPC_CREAT);
   //创建共享内存
  ishmid = shmget((key_t)1234,sizeof(struct shared_use_str),0666|IPC_CREAT);
    
  if(-1 == ishmid)
  {
      printf("shmid failed\n");
      exit(-1);
  }
  //得到共享内存
  pMem = shmat(ishmid,(void *)0,0);
  if(pMem == (void *)-1)
  {
    printf("shmat failed\n");
    exit(-1);
  }
    
  printf("Memory Attached at %X\n",pMem);
    
  pshared_use_str = (struct shared_use_str *) pMem;
  pshared_use_str->iwrite_by_you = 0;
    
  while(true == isRuning)
  {
         //获得排它锁
   if(!semaphore_p())
   {
     printf("semp p failed\n");
     exit(-1);
   }
    printf("you write %s\n",pshared_use_str->somedate);
    sleep(rand()%5);
    pshared_use_str->iwrite_by_you = 0;
    if(strncmp(pshared_use_str->somedate,"end",3) == 0)
    {
      isRuning = false;
    } 
     if(!semaphore_v())
   {
     printf("failed to set v \n");
     exit(-1);
   } 
  } 
  //共享内存分离
  if(shmdt(pMem) == -1)
  {
    printf("shmdt failed\n");
    exit(-1);
  } 
  //删除共享内存
  if(shmctl(ishmid,IPC_RMID,0) == -1)
  {
    printf("shmctl failed\n");
    exit(-1);
  } 
    
  return 0;
}
static void del_semvalue(void )
{
 union semun sem_unition;
 //删除信号量
 if(semctl(sem_id,0,IPC_RMID,sem_unition) == -1)
 {
   printf("failed to semctl\n");
   return;
 } 
}
static int semaphore_p(void )
{
 struct sembuf sem_b;
 sem_b.sem_num = 0;
 sem_b.sem_op = -1;
 sem_b.sem_flg = SEM_UNDO;
//获得信号量 ，并进行减1操作，信号量为0之后挂起。禁止其它进程访问
if(-1 == semop(sem_id,&sem_b,1))
 {
   printf("semaphore failed\n");
   return 0;
 } 
 return 1;
}
static int semaphore_v(void )
{
 struct sembuf sem_b;
 sem_b.sem_num = 0;
 sem_b.sem_op = 1;
 sem_b.sem_flg = SEM_UNDO;
//释放信号量 ，并进行加1操作，信号量大于0之后执行。其它进程可以访问
 if(-1 == semop(sem_id,&sem_b,1))
 {
   printf("semaphore failed\n");
   return 0;
 } 
 return 1;
}

本文出自 “风清扬song” 博客，请务必保留此出处http://2309998.blog.51cto.com/2299998/1398335

linux 进程间通信使用共享内存,古老的榕树,5-wow.com