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 <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
// 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 <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,"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 <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
#include <sys/shm.h>
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");
}
执行结果：
运用信号量与共享内存的配合使用，可以完美实现共享内存写入与读取，无需再进行延时操作。
777
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
