IPC对象之信号量
1. 信号量
1）信号量（semaphore）,也叫信号灯。它是不同进程间或一个给定进程内部不同线程间同步的机制。
2）二值信号量：值为0或1。与互斥锁类似，资源可用时值为1，不可用时值为0。
3）计数信号量：值在0到n之间。同来统计资源，其值代表可用资源数。
4）等待操作是等待信号量的值变为大于0，然后将其减一；而释放操作则相反，用来唤醒等待资源的进程或者线程。
2. 信号量编程函数
在Linux系统中，使用信号量通常需要创建信号量、初始化信号量、信号量PV操作以及信号量删除四种操作。
1）创建信号量
函数semget()
所需头文件：#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
函数原型：int semget(key_t key, int nsems, intsemflg)
函数参数：
key 信号量的键值，其他进程通过该值访问该信号量，其中有个特殊值IPC_PRIVATE，表示创建当前进程的私有信号量
nsems 需要创建的信号量数目，通常为1。若创建多个信号量则称为信号量集
semflg 同open()函数的第三个参数，为信号量设定权限，通常使用八进制表示。
函数返回值：
成功：信号量的标识符（非负整数）
失败：-1
2）初始化信号量，函数semctl()用于对信号量进行相应的控制，包括设置初始化值、获取信息、设置属性、删除信号量（集）等操作
函数semctl()
头文件：#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
函数原型：int semctl(int semid, int semnum, intcmd, union semun arg)
函数参数：
semid 信号量标识符（即semget()函数的返回值）
semnum 信号量编号，通常存在多个信号量时才会使用。通常取值为0，即第一个信号量。
cmd 需要对信号量采取的操作。可取值有很多，常用的有：
IPC_STAT 读取消息队列的数据结构semid_ds并将其存储在第四个参数arg结构变量的buf指定的地址中
IPC_SETVAL 将信号量值设定为arg中的val值
IPC_GETVAL 获取当前信号量的值
IPC_RMID 从内核中删除信号量（集）
arg 是一个union semun结构的共用体，常用类型如下：
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) */
};
注意：某些系统内未给出union semun的定义，需要程序员自己定义该共用体。
其中buf参数是一个semid_ds类型的结构体指针，使用时必须使用地址传递的方式。结构体成员很多，常用的有：
struct semid_ds
{
uid_t sem_perm.uid; /* Effective UID of owner*/
gid_t sem_perm.gid; /* Effective GID of owner*/
……
};
函数返回值：成功：
IPC_STAT、IPC_SETVAL或IPC_RMID操作：0
IPC_GETVAL操作：返回当前信号量的值
失败：-1
3）信号量PV操作
函数semop()
头文件：#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
函数原型：int semop(int semid, struct sembuf*sops, size_t nsops)
函数参数：
semid 信号量标识符（即semget()函数的返回值）
sops 是一个sembuf类型的结构体指针，使用时必须使用地址传递的方式。结构体类型如下：
struct sembuf
{
unsigned short sem_num;//信号量编号，若是单个信号量则取值0
short sem_op;//取值-1为P操作，取值1为V操作
short sem_flg;//通常取值SEM_UNDO，表示进程结束后系统自动释放该进程中未释放的信号量
}
nsops 需要操作的信号量数目，通常取值1（一个操作）
函数返回值：
成功：信号量的标识符
失败：-1
示例：有两个进程，进程A和进程B，这两个进程通过共享内存通信，进程A负责写内存，进程B负责读内存。要求进程A写一次，然后B读一次。这里用两个信号量进行读写的同步。（在博文：IPC对象之共享内存中使用无名管道进行都写得同步）。
方法一程序结构图如下：
示例代码：
/*************************************************************************
@Author: wanghao
@Created Time : Wed 23 May 2018 07:37:06 PMPDT
@File Name: sem_demo.c
@Description:
************************************************************************/
#include <sys/shm.h>
#include <sys/sem.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
/*The structure that stores the data*/
typedef struct{
int val;
int semid;
}Storage;
void init(Storage *s)
{
assert(s!= NULL);
/*Create semaphore, return semaphore value*/
if((s->semid= semget(IPC_PRIVATE,2,IPC_CREAT|IPC_EXCL|0777)) <0){
perror("semgeterror");
exit(1);
}
/*Define union semun struct*/
union semun{
int val;
struct semid_ds *ds;
unsigned short *array;
};
union semun un;
/*Each value in the semaphore*/
unsigned short array[2] = {0,1};
un.array= array;
/*Set all values in the semaphore*/
if(semctl(s->semid,0,SETALL,un)<0){
perror("semctrlerror");
exit(1);
}
}
void destroy(Storage *s)
{
assert(s!= NULL);
/*Delete semaphore*/
if(semctl(s->semid,0,IPC_RMID,NULL)<0){
perror("semctlerror");
exit(1);
}
}
void write(Storage *s, int val)
{
/*Set semaphore 0 to V Operation*/
struct sembuf ops_v[1] = {{0,1,SEM_UNDO}};
/*Set semaphore 1 to P Operation*/
struct sembuf ops_p[1] = {{1,-1,SEM_UNDO}};
/*Set semaphore 1 to P Operation*/
if(semop(s->semid,ops_p,1)<0){
perror("semoperror");
}
s->val= val;
printf("%d write %d\n",getpid(),val);
/*Set semaphore 1 to V Operation*/
if(semop(s->semid,ops_v,1)<0){
perror("semoperror");
}
}
void read(Storage *s)
{
assert(s!= NULL);
/*Setsemaphore 0 to P Operation*/
struct sembuf ops_p[1] = {{0,-1,SEM_UNDO}};
/*Set semaphore 0 to V Operation*/
struct sembuf ops_v[1] = {{1,1,SEM_UNDO}};
/*Set semaphore 0 to P Operation*/
if(semop(s->semid,ops_p,1)<0){
perror("semoperror");
}
printf("%d read %d\n",getpid(),s->val);
/*Setsemaphore 0 to V Operation*/
if(semop(s->semid,ops_v,1)<0 ){
perror("semoperror");
}
}
int main(void)
{
intshmid;
/*Create Shared Memory, size is sizeof Storage*/
if((shmid= shmget(IPC_PRIVATE,sizeof(Storage),
IPC_CREAT|IPC_EXCL|0777))< 0){
perror("shmgeterror");
exit(1);
}
/*Map shared memory*/
Storage *s = (Storage*) shmat(shmid,0,0);
if(s== (Storage*) -1){
perror("shmaterror");
exit(1);
}
init(s);
pid_tpid;
pid= fork();
if(pid<0){
perror("forkerror");
exit(1);
}else if(pid > 0){
inti = 1;
for(;i<=100; i++){
write(s,i);
}
wait(NULL);
/*Deletesemaphore*/
destroy(s);
/*Unlocka shared memory map*/
shmdt(s);
/*Deletememory*/
shmctl(shmid,IPC_RMID,NULL);
}else{
int i = 1;
for(;i<=100;i++){
read(s);
}
/*Unlocka shared memory map*/
shmdt(s);
}
exit(0);
}
方法二程序结构图如下：
示例代码如下，与方法1的不同之处，用红笔标出。
/*************************************************************************
@Author: wanghao
@Created Time : Wed 23 May 2018 07:42:18 PMPDT
@File Name: sem_demo1.c
@Description:
************************************************************************/
#include <sys/shm.h>
#include <sys/sem.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
/*The structure that stores the data*/
typedef struct{
intval;
intsemid;
}Storage;
void init(Storage *s)
{
assert(s!= NULL);
/*Createsemaphore, return semaphore value*/
if((s->semid= semget(IPC_PRIVATE,2,IPC_CREAT|IPC_EXCL|0777)) <0){
perror("semgeterror");
exit(1);
}
/*Defineunion semun struct*/
unionsemun{
intval;
structsemid_ds *ds;
unsignedshort *array;
};
union semun un;
/*Eachvalue in the semaphore*/
unsigned short array[2] = {0,0};
un.array= array;
/*Setall values in the semaphore*/
if(semctl(s->semid,0,SETALL,un)<0){
perror("semctrlerror");
exit(1);
}
}
void destroy(Storage *s)
{
assert(s!= NULL);
/*Deletesemaphore*/
if(semctl(s->semid,0,IPC_RMID,NULL)<0){
perror("semctlerror");
exit(1);
}
}
void write(Storage *s, int val)
{
/*Set semaphore 0 to V Operation*/
struct sembuf ops_v[1] = {{0,1,SEM_UNDO}};
/*Set semaphore 1 to P Operation*/
struct sembuf ops_p[1] = {{1,-1,SEM_UNDO}};
s->val = val;
printf("%d write %d\n",getpid(),val);
/*Set semaphore 1 to V Operation*/
if(semop(s->semid,ops_v,1) <0){
perror("semop error");
}
/*Set semaphore 1 to P Operation*/
if(semop(s->semid,ops_p,1)<0){
perror("semop error");
}
}
void read(Storage *s)
{
assert(s!= NULL);
/*Setsemaphore 0 to P Operation*/
structsembuf ops_p[1] = {{0,-1,SEM_UNDO}};
/*Setsemaphore 0 to V Operation*/
structsembuf ops_v[1] = {{1,1,SEM_UNDO}};
/*Setsemaphore 0 to P Operation*/
if(semop(s->semid,ops_p,1)<0){
perror("semoperror");
}
printf("%dread %d\n",getpid(),s->val);
/*Setsemaphore 0 to V Operation*/
if(semop(s->semid,ops_v,1)<0 ){
perror("semoperror");
}
}
int main(void)
{
intshmid;
/*CreateShared Memory, size is sizeof Storage*/
if((shmid= shmget(IPC_PRIVATE,sizeof(Storage),
IPC_CREAT|IPC_EXCL|0777))< 0){
perror("shmgeterror");
exit(1);
}
/*Mapshared memory*/
Storage*s = (Storage*) shmat(shmid,0,0);
if(s== (Storage*) -1){
perror("shmaterror");
exit(1);
}
init(s);
pid_tpid;
pid= fork();
if(pid<0){
perror("forkerror");
exit(1);
}elseif(pid > 0){
inti = 1;
for(;i<=100; i++){
write(s,i);
}
wait(NULL);
/*Deletesemaphore*/
destroy(s);
/*Unlocka shared memory map*/
shmdt(s);
/*Deletememory*/
shmctl(shmid,IPC_RMID,NULL);
}else{
inti = 1;
for(;i<=100;i++){
read(s);
}
/*Unlocka shared memory map*/
shmdt(s);
}
exit(0);
}