Linux进程通信——信号量详解 共享内存与信号量配合使用

  1. Linux进程通信——信号量

  • 什么是信号量:

信号量实际是一个计数器。信号量用于实现进程间的互斥与同步,而不是用于存储 进程间通信 数据。很多进程会访问同一资源,或者向共享内存写入一些东西,为防止争夺资源混乱。可以给一些进程上锁,让其排队等待
  • 特点:

1 信号量用于进程间同步,若要在进程间传递数据需要结合 共享内存
2 信号量基于操作系统的 PV 操作,程序对信号量的操作都是原子操作。
3 每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1,而且可以加减任意正整数。
4 支持信号量组

2.信号量原型函数:

// 创建或获取一个信号量组:若成功返回信号量集ID,失败返回-1
int semget(key_t key, int num_sems, int sem_flags);
// 对信号量组进行操作,改变信号量的值:成功返回0,失败返回-1
int semop(int semid, struct sembuf semoparray[], size_t numops);  
// 控制信号量的相关信息
int semctl(int semid, int sem_num, int cmd, ...);
  • num_sems为钥匙的数量,通常为1

在semop函数中,sembuf结构体如下:

struct sembuf 
{
    short sem_num; // 信号量组中对应的序号,0~sem_nums-1
    short sem_op;  // 信号量值在一次操作中的改变量
    short sem_flg; // IPC_NOWAIT, SEM_UNDO
}

3.共享内存的定义

由于进程通信的本质是要让两个不同的进程看到同一份资源,我们可以在物理内存上开辟一块空间,这块空间被称为 共享内存 ,然后让这两个进程通过某种方式都能访问到这块内存,这样的话,两个进程之间就可以通信了。

注意:共享内存操作默认不阻塞,如果多个进程同时读写共享内存,可能出现数据混乱,共享内存需要借助其他机制来保证进程间的数据同步,比如:信号量,共享内存内部没有提供这种机制。

共享内存函数的原型:

// 创建或获取一个共享内存:成功返回共享内存ID,失败返回-1
int shmget(key_t key, size_t size, int flag);
// 连接共享内存到当前进程的地址空间:成功返回指向共享内存的指针,失败返回-1
void *shmat(int shm_id, const void *addr, int flag);
// 断开与共享内存的连接:成功返回0,失败返回-1
int shmdt(void *addr); 
// 控制共享内存的相关信息:成功返回0,失败返回-1
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

例程(信号量控制子进程先运行):

#include 
#include 
#include 
#include 
#include 

// unsigned short sem_num;  /* semaphore number */
//           short          sem_op;   /* semaphore operation */
//           short          sem_flg;  /* operation flags */

union semun{
               int              val;    /* Value for SETVAL */
               struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
               unsigned short  *array;  /* Array for GETALL, SETALL */
               struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
           };

void getkey(int semid)//得到钥匙
{
    struct sembuf sop;
    sop.sem_num = 0;//控制第一个信号量
    sop.sem_op  = -1;//钥匙数量减一6
    sop.sem_flg = SEM_UNDO;
    semop(semid,&sop,1);
}

void backkey(int semid)//放回钥匙
{
    struct sembuf sop;
    sop.sem_num = 0;
    sop.sem_op  = 1;
    sop.sem_flg = SEM_UNDO;
    semop(semid,&sop,1);
}

int main()
{
   int semid;
   key_t key;
   pid_t pid;
   key = ftok(".",1);
   semid = semget(key,1,IPC_CREAT|0666);//创建信号量
   union semun set;
   set.val = 0;//钥匙数量为0
   semctl(semid,0,SETVAL,set);//对信号量进行控制,第0个信号量,SETVAL将初始化信号量为一个已知的值,set为联合共用体,设置初始钥匙数量
   
   pid = fork();
   if(pid>0)
   {//父进程是没有钥匙的是无法运行的,阻塞状态。只能等待子进程放回钥匙
       getkey(semid);//父进程获得钥匙,执行下面内容
       printf("this is father!======\n");
       backkey(semid);//放回钥匙
       semctl(semid,0,IPC_RMID);//销毁信号量
   }
   else if(pid==0)
   {
       printf("this is child!=========\n");//
       backkey(semid);//子进程放回钥匙
   }
}

执行结果:

4.信号量与共享内存配合使用:

信号量结合共享内存的写端: write.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// 创建或获取一个信号量组:若成功返回信号量集ID,失败返回-1
//int semget(key_t key, int num_sems, int sem_flags);
// 对信号量组进行操作,改变信号量的值:成功返回0,失败返回-1
//int semop(int semid, struct sembuf semoparray[], size_t numops);  
// 控制信号量的相关信息
//int semctl(int semid, int sem_num, int cmd, ...);

// unsigned short sem_num;  /* semaphore number */
//           short          sem_op;   /* semaphore operation */
//           short          sem_flg;  /* operation flags */


// 创建或获取一个共享内存:成功返回共享内存ID,失败返回-1
//int shmget(key_t key, size_t size, int flag);
// 连接共享内存到当前进程的地址空间:成功返回指向共享内存的指针,失败返回-1
//void *shmat(int shm_id, const void *addr, int flag);
// 断开与共享内存的连接:成功返回0,失败返回-1
//int shmdt(void *addr); 
// 控制共享内存的相关信息:成功返回0,失败返回-1
//int shmctl(int shm_id, int cmd, struct shmid_ds *buf);
union semun{
               int              val;    /* Value for SETVAL */
               struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
               unsigned short  *array;  /* Array for GETALL, SETALL */
               struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
           };

void p(int semid,int num)
{
    struct sembuf sop;
    sop.sem_num = num;
    sop.sem_op  = -1;
    sop.sem_flg = SEM_UNDO;
    semop(semid,&sop,1);//上锁操作
}

void v(int semid,int num)
{
    struct sembuf sop;
    sop.sem_num = num;
    sop.sem_op  = 1;
    sop.sem_flg = SEM_UNDO;
    semop(semid,&sop,1);//放锁操作
}

int main()
{
   int semid;
   int shmid;
   char *shmaddr;//用于shmat返回返回共享内存空间
   key_t key1;
   key_t key2;//创建key值
   key1 = ftok(".",1);
   key2 = ftok(".",2);//建立Key值
   shmid = shmget(key1,1024,IPC_CREAT|0666);//创建共享内存
   semid = semget(key2,2,IPC_CREAT|0666);//创建信号量
   union semun set1;
   set1.val = 1;//第一个信号量锁数量为1
   semctl(semid,0,SETVAL,set1);
   union semun set2;
   set2.val = 0;//第二个信号量锁数量为0
   
   p(semid,0);//对第一个信号上锁,只允许写入操作
   shmaddr = shmat(shmid,0,0);//进程连接共享内存
   strcpy(shmaddr,"you are a handsome boy");//将内容写入共享内存
   shmdt(shmaddr);//断开共享内存
   v(semid,1);//对第二个信号释放,目的是能让读入端进程读取内容
   
   p(semid,0);//当读入端完成后,会上第一把锁,能消除信号量和共享内存
   shmctl(shmid,IPC_RMID,0);
   semctl(semid,0,IPC_RMID);
   semctl(semid,1,IPC_RMID);//一系列删除操作
   printf("write down!\n");
}

信号量结合共享内存的读端: read.c

#include 
#include 
#include 
#include 
#include 
#include 

union semun{
               int              val;    /* Value for SETVAL */
               struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
               unsigned short  *array;  /* Array for GETALL, SETALL */
               struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
           };

void p(int semid,int num)
{
    struct sembuf sop;
    sop.sem_num = num;
    sop.sem_op  = -1;
    sop.sem_flg = SEM_UNDO;
    semop(semid,&sop,1);
}

void v(int semid,int num)
{
    struct sembuf sop;
    sop.sem_num = num;
    sop.sem_op  = 1;
    sop.sem_flg = SEM_UNDO;
    semop(semid,&sop,1);
}

int main()
{
   int semid;
   int shmid;
   char *shmaddr;
   key_t key1;
   key_t key2;
   key1 = ftok(".",1);
   key2 = ftok(".",2);
   shmid = shmget(key1,1024,IPC_CREAT|0666);
   semid = semget(key2,2,IPC_CREAT|0666);
   union semun set1;
   set1.val = 1;
   semctl(semid,0,SETVAL,set1);
   union semun set2;
   set2.val = 0;
   
   p(semid,1);//上第二把锁,代表写入完成可以读取
   shmaddr = shmat(shmid,0,0);//连接共享内存
   printf("contect:%s\n",shmaddr);//打印内容
   shmdt(shmaddr);
   v(semid,0);//释放第一把锁,代表可以删除共享内存
   printf("read down!\n");
}

执行结果:

  • 运用信号量与共享内存的配合使用,可以完美实现共享内存写入与读取,无需再进行延时操作。

你可能感兴趣的:(linux,c语言,unix)