进程间通讯之信号量（实例）

1、信号量

特点：
1、信号量是一个计数器，用于多进程对共享数据对象的访问。
2、信号量的初始值是任一正数，说明有多少个共享资源单位可供共享应用。（常用的信号量形式：初始值为1，即某一资源某一时刻只能给单一进程占有。称为二元信号量或双态信号量）。

控制过程：
①、测试控制该资源的信号量。
②、若信号量的值为正，则进程可以使用该资源。进程将信号量的值减1，表示它使用了一个资源单位。
③、若信号量的值为0，则进程进入休眠状态，直到进程信号量大于1.进程被唤醒，再返回①。
④、当进程不在使用共享资源的时候，该信号量的值+1。若其它有进程等待此信号量，则唤醒它。

应用：
常用于进程的同步，例如多进程项目的log打印或写文件。

2、信号量集

信号量集：信号量的集合
当创建一个信号量集时，要指定该集合中信号量的数量
创建信号量集（semget）与对其赋初值（semctl）应一起，不要分开。

a、创建信号量 或 获取现在存的信号量：
int semget(key_t key,int nsems,int flag)
key：键值
nsems:表示信号量的数量
flag :同msgget

b、操作一个现有的信号量
int semctl(int semid,int semnum,int cmd,.../* union semun arg */)
semid：semget返回的信号量ID

semnum: [0] -- [nsems-1]信号量集合，即有nsems个信号量
c、操作信号量资源
int semop(int semid,struct sembuf semoparray[],size_t nops) //nops 操作几个信号量

3、实例

3.1、semget、semctl

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define    NR     5
#define    OP_ALL

int main(void)
{
int i,ret,semid;
//NR:信号量数组中的信号量个数
semid=semget(0x555,NR,IPC_CREAT|0644);//0x555键值，随便写的一个全局的键值

if(semid==-1)
{
perror("semget");
return 1;
}
printf("semid:%d\n",semid);
//--------------设置信号量值------------------------
#ifndef OP_ALL//逐一赋值
for(i=0;i<NR;i++)
{
ret=semctl(semid,i,SETVAL,1);
if(ret==-1)    return 2;
}
#else//整体赋值
unsigned short  val[NR]={1,1,1,1,1};
ret=semctl(semid,0,SETALL,val);
if(ret==-1)        return 2;//error
#endif //
//---------------get semval-------------------------
#ifndef OP_ALL//逐一获取
for(i=0;i<NR;i++)
{
ret=semctl(semid,i,GETVAL);
if(ret==-1)     return 3;
printf("%dth==>val:%d\n",i,ret);
}
#else//整体获取
unsigned short  temp[NR];
ret=semctl(semid,0,GETALL,temp);
if(ret==-1)        return 3;//error
for(i=0;i<NR;i++)
printf("%dth==>val:%d\n",i,temp[i]);
#endif //
//---------------------------------------------------

getchar();
printf("===============del sem array==========\n");
semctl(semid,0,IPC_RMID);//删除信号量
return 0;
}

3.2、父子进程同步打印字符（semop应用）

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define    NR     1
//申请资源
void p_lock(int semid);
//释放资源
void v_unlock(int semid);

int main(void)
{
pid_t pid;
int   ret,semid;

semid=semget(0x555,NR,IPC_CREAT|0644);
if(semid==-1)   return 11;
ret=semctl(semid,0,SETVAL,10);
if(ret==-1)     return 22;
//------------------------------------------
pid=fork();
if(pid==-1)   return 1;
else if(pid==0)  //child
{
char i,*str="1234567890";
for(i=0;str[i];i++)
{
p_lock(semid);
write(STDOUT_FILENO,str+i,1);
usleep(500000);
v_unlock(semid);
}
exit(0);
}
//parent
char i,*str="abcdefghij";
for(i=0;str[i];i++)
{
p_lock(semid);
write(STDOUT_FILENO,str+i,1);
sleep(2);
v_unlock(semid);
}
wait(NULL);
putchar('\n');
return 0;
}
void p_lock(int semid)
{
struct sembuf buf={.sem_num=0,.sem_op=-10};
semop(semid,&buf,1);
}
void v_unlock(int semid)
{
struct sembuf buf={.sem_num=0,.sem_op= 10};
semop(semid,&buf,1);
}

3.3、文件同步写

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>

#include <sys/ipc.h>
#include <sys/sem.h>

#define     TIMES    1000000

static int  semid;

void write_file(int fd);

void unlock(void);
void lock(void);

int main(void)
{
int ret,fd,val=0;
pid_t pid;

fd=open("./txt",O_RDWR|O_TRUNC|O_CREAT,0644);
if(fd==-1)   return 1;

pwrite(fd,&val,sizeof(int),0);
//----------------------------------------
semid=semget(0x555,1,IPC_CREAT|0644);//创建一个信号量
if(semid==-1)   return    11;
ret=semctl(semid,0,SETVAL,1);//设置一个信号量，资源为1
if(ret==-1)     return    22;
//-----------------------------------------
pid=fork();
if(pid==-1)   return 2;//error
else if(pid==0)  //child
{
printf("child start......\n");
write_file(fd);
printf("child write file over\n");
close(fd);
exit(0);
}
//parent
printf("parent write file\n");
write_file(fd);
wait(NULL);

pread(fd,&val,sizeof(int),0);
printf("====>val:%d\n",val);

close(fd);
return 0;
}
void write_file(int fd)
{
int i,val;

for(i=0;i<TIMES;i++)
{
//lock
lock();
pread(fd,&val,sizeof(int),0);
val+=1;
pwrite(fd,&val,sizeof(int),0);
unlock();
//unlock
}
}

void lock(void)
{
struct sembuf  buf={.sem_op=-1,.sem_num=0};
semop(semid,&buf,1);
}
void unlock(void)
{
struct sembuf  buf={.sem_op=1,.sem_num=0};
semop(semid,&buf,1);
}

3.4、等0操作

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define    NR       1

void v_unlock(int semid);
void p_lock(int semid);

int main(void)
{
int i,ret,semid;
pid_t  pid;

semid=semget(0x666,NR,IPC_CREAT|0644);
if(semid==-1)   return 1;
ret=semctl(semid,0,SETVAL,10);
if(ret==-1)     return 2;

pid=fork();
if(pid==-1)    return 1;
else if(pid==0) //child
{
while(1)
{
for(i=0;i<10;i++)
{
p_lock(semid);
printf("===child:%d=====\n",i);
sleep(1);
}
}
}
//parent
struct sembuf zero={.sem_num=0,.sem_op=0};
while(1)
{
//wait zero
semop(semid,&zero,1);
printf("==========parent=========\n");
v_unlock(semid);
}

return 0;
}
void v_unlock(int semid)
{
struct sembuf buf={.sem_num=0,.sem_op=10};
semop(semid,&buf,1);
}
void p_lock(int semid)
{
struct sembuf buf={.sem_num=0,.sem_op=-1};
semop(semid,&buf,1);
}

3.5、栅栏程序模型

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#include <signal.h>

#define     NR      5

static int semid;
void sigfunc(int signo)
{
if(signo!=SIGINT)  return;
semctl(semid,0,IPC_RMID);
exit(0);
}
void do_work(int index);
void p_lock(int index);

int main(void)
{
int    i;
pid_t  pid;

signal(SIGINT,sigfunc);//is error

//------create sem-----------------
//对应的信号量用控制对应的子进程 最后一个用于父进程控制周期
semid=semget(0x555,NR+1,IPC_CREAT|0644);
if(semid==-1)
{
perror("semget");
return 1;
}
unsigned short val[NR+1]={0};
i=semctl(semid,0,SETALL,val);
if(i==-1)
{
perror("semctl");
return 2;
}
//-----------------------------------
for(i=0;i<NR;i++)
{
pid=fork();
if(pid==-1)   return 1;
else if(pid==0)//child
{
do_work(i);
exit(0);
}
}
//---------------给定子进程资源---------------
struct sembuf ar[NR+1],zero={.sem_num=NR,.sem_op=0};
for(i=0;i<NR;i++)
{
ar[i].sem_op =1;
ar[i].sem_num=i;
}
ar[NR].sem_num=NR;
ar[NR].sem_op =NR;
//-----------------------------------
while(1)
{
semop(semid,&zero,1);//等0操作
printf("==========================\n");

semop(semid,ar,NR+1);
}

while(wait(NULL)!=-1)
;//empty
return 0;
}

void do_work(int index)
{
int sec;
srand(getpid());
while(1)
{
p_lock(index);
sec=rand()%6+1;
sleep(sec);
printf("%d:[%d] sleep:%d\n",index,getpid(),sec);
//通知父进程已跑完
p_lock(NR);
}
}
void p_lock(int index)
{
struct sembuf  s={.sem_num=index,.sem_op=-1};
if(semop(semid,&s,1)==-1)
{
perror("semop");
exit(1);
}
}