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

什么是信号量：

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

特点：

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

信号量原型函数：

// 创建或获取一个信号量组：若成功返回信号量集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
}

在semctl中，常见的参数为
SETVAL：用于初始化信号量为一个已知的值。
IPC_RMID：删除一个信号量集合。否则会造成其他进程信号混乱，而且信号是有限的资源

例程（信号量控制子进程先运行）：

用fork建立一个进程，锁住父进程，让子进程先运行

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
// 创建或获取一个信号量组：若成功返回信号量集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 */

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);//子进程放回钥匙
   }
}

运行效果如下，无论运行多少次，都是子进程先运行：

信号量与共享内存配合使用：

写入端：shw.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
#include <sys/shm.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
// 创建或获取一个信号量组：若成功返回信号量集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,"this write program");//将内容写入共享内存
   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");
}

读入端 shmr.c （对已经解释的内容不在注释）
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
#include <sys/shm.h>
// 创建或获取一个信号量组：若成功返回信号量集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;
   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");
}

效果如下：

读取成功

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