一、进程间通信概述
进程间通信(IPC,InterProcess Communication)是指在不同进程之间传播或交换信息。IPC的方式通常有管道(包括无名管道和命名管道)、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。
二、管道通信原理
1.什么是管道?
一个进程连接到另一个进程的一个数据流称为一个“管道”
2.特点
1)它是半双工的(即数据只能在一个方向上流动),具有固定的读端和写端。
2)它只能用于具有亲缘关系的进程之间的通信(也是父子进程或者兄弟进程之间)。
3)它可以看成是一种特殊的文件,对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件,并不属于其他任何文件系统,并且只存在于内存中。
3.pipe函数原型
#include <unistd.h>
int pipe(int fd[2]); // 返回值:若成功返回0,失败返回-1
功 能:创建一无名管道
参 数::int pipefd[2]文件描述符数组,其中fd[0]表示读端,fd[1]表示写端
返回值:成功返回0,失败返回-1
4.开辟了管道之后如何实现两个进程间的通信呢?
1)父进程调用pipe开辟管道,得到两个文件描述符指向管道的两端。
2)父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同一管道。
3)父进程关闭管道读端,子进程关闭管道写端。父进程可以往管道里写,子进程可以从
4)管道里读,管道是用环形队列实现的,数据从写端流入从读端流出,这样就实现了进程间通信。
5.管道中的数据被读走就没了,它是储存在磁盘内存当中的
#include <unistd.h>
#include<stdio.h>
#include<string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include<stdlib.h>
int main()
{
int fd[2];
int pid;
char buf[128];
if(pipe(fd) == -1){
printf("创建管道失败!\n");
}
pid = fork();
if(pid < 0){
printf("创建子进程失败!\n");
}else if(pid > 0){
sleep(3);
printf("欢迎来到父进程!\n");
close(fd[0]);
write(fd[1],"hello from father",strlen("hello from father"));
wait(0);
}else{
printf("欢迎来到子进程!\n");
close(fd[1]);
read(fd[0],buf,128);
printf("管道读取到的数据是:%s\n",buf);
exit(0);
}
return 0;
}
运行结果:
三、命名管道
1.FIFO
也称为命名管道,它是一种文件类型。
2.特点
1)FIFO可以在无相关的进程之间交换数据,与无名管道不同。
2)FIFOO有路径名与之相关联,它以一种特殊设备文件形式存在于文件系统中。
3.原型
#include <sys/stat.h>
// 返回值:成功返回0,出错返回-1
int mkfifo(const char *pathname, mode_t mode);
其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO,就可以用一般的文件I/O函数操作它。
当 open 一个FIFO时,是否设置非阻塞标志(O_NONBLOCK)的区别:
1)若没有指定O_NONBLOCK(默认),只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的,只写 open 要阻塞到某个其他进程为读而打开它。**
2)若指定了O_NONBLOCK,则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO,其errno置ENXIO。
4.创建命名管道
#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include<errno.h>
//int mkfifo(const char *pathname, mode_t mode);
int main()
{
if(mkfifo("./file",0600) == -1 && errno == EEXIST){
printf("创建命名管道失败!\n");
perror("why");
}
return 0;
}
运行结果:
5.命名管道的数据通信编程实现
读取端代码
#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include<errno.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
char buf[50] = {0};
if(mkfifo("./file",0600) == -1 && errno == EEXIST){
printf("创建命名管道失败!\n");
perror("why");
}
int fd = open("./file",O_RDONLY);
printf("打开文件成功!\n");
while(1){
sleep(1);
int nread = read(fd,buf,50);
printf("读到的文件大小是:%d 读取到的内容是:%s\n",nread,buf);
}
close(fd);
return 0;
}
写入段代码
#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include<errno.h>
#include <fcntl.h>
#include <unistd.h>
#include<string.h>
int main()
{
char *str = "i am handsome";
int cnt = 0;
int fd = open("./file",O_WRONLY);
printf("write打开文件成功!\n");
while(1){
cnt ++;
sleep(1);
write(fd,str,strlen(str));
if(cnt == 5){
break;
}
}
close(fd);
return 0;
}
运行结果:
四、消息队列
1.什么是消息队列?
是消息的链接表,存放在内核中。一个消息队列由一个标识符(即队列ID)来标识。
2.特点
1)消息队列是面向记录的,其中的消息具有特定的格式以及特定的优先级。
2)消息队列独立于发送与接收进程。进程终止时,消息队列及其内容并不会被删除。
3)消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
3.原型
#include <sys/msg.h>
// 创建或打开消息队列:成功返回队列ID,失败返回-1
int msgget(key_t key, int flag);
// 添加消息:成功返回0,失败返回-1
int msgsnd(int msqid, const void *ptr, size_t size, int flag);
// 读取消息:成功返回消息数据的长度,失败返回-1
int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
// 控制消息队列:成功返回0,失败返回-1
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
4.在以下两种情况下,msgget将创建一个新的消息队列:
a)如果没有与键值key相对应的消息队列,并且flag中包含了IPC_CREAT标志位。
b)key参数为IPC_PRIVATE。
5.函数msgrcv在读取消息队列时,type参数有下面几种情况:
type == 0,返回队列中的第一个消息;
type > 0,返回队列中消息类型为 type 的第一个消息;
type < 0,返回队列中消息类型值小于或等于 type 绝对值的消息,如果有多个,则取类型值最小的消息。
6.ftok函数
系统建立IPC通讯(如消息队列、共享内存时)必须指定一个ID值。通常情况下,该id值通过ftok函数得到。
函数原型:
key_t ftok(const char *pathname, int proj_id);
参数说明:pthname就是你指定的文件名(该文件必须是存在而且可以访问的),id是子序号, 虽然为int,但是只有8个比特被使用(0-255)。
当成功执行的时候,一个key_t值将会被返回,否则 -1 被返回。
7.先发送再接收代码段
#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<sys/ipc.h>
//int msgget(key_t key, int msgflg);
// int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
// int msgflg);
struct msbuf
{
long mtype;
char mtext[128];
};
int main()
{
struct msbuf sendBuf = {888,"i am handsome"};
struct msbuf getBuf2;
key_t key;
key = ftok(".",'z');
printf("key = %x\n",key);
int msgId = msgget(key,IPC_CREAT|0777);
if(msgId == -1){
printf("创建消息队列失败!\n");
}
msgsnd(msgId,&sendBuf,sizeof(sendBuf.mtext),0);
msgrcv(msgId,&getBuf2,sizeof(getBuf2.mtext),666,0);
printf("接收到的数据是:%s\n",getBuf2.mtext);
msgctl(msgId,IPC_RMID,NULL);//做完就移除,避免过多内存消耗
return 0;
}
先接收后发送代码段
#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<sys/ipc.h>
//int msgget(key_t key, int msgflg);
// int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
// int msgflg);
struct msbuf
{
long mtype;
char mtext[128];
};
int main()
{
struct msbuf getBuf;
struct msbuf sendBuf2 = {666,"装,还拽英文,小丑是你"};
key_t key;
key = ftok(".",'z');
printf("key = %x\n",key);
int msgId = msgget(key,IPC_CREAT|0777);
if(msgId == -1){
printf("创建消息队列失败!\n");
}
msgrcv(msgId,&getBuf,sizeof(getBuf.mtext),888,0);
printf("接收到的数据是:%s\n",getBuf.mtext);
msgsnd(msgId,&sendBuf2,sizeof(sendBuf2.mtext),0);
msgctl(msgId,IPC_RMID,NULL);//做完就移除,避免过多内存消耗
return 0;
}
运行结果:
五、共享内存
1.什么是共享内存?
指两个或多个进程共享一个给定的存储区。
2.共享内存的特点:
1)共享内存是最快的一种 IPC,因为进程是直接对内存进行存取。
2)因为多个进程可以同时操作,所以需要进行同步。
3.函数原型:
#include <sys/shm.h>
// 创建或获取一个共享内存:成功返回共享内存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);
1)当用shmget函数创建一段共享内存时,必须指定其 size;而如果引用一个已存在的共享内存,则将 size 指定为0 。
2)当一段共享内存被创建以后,它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间,连接成功后把共享内存区对象映射到调用进程的地址空间,随后可像本地空间一样访问。
3)shmdt函数是用来断开shmat建立的连接的。注意,这并不是从系统中删除该共享内存,只是当前进程不能再访问该共享内存而已。
4)shmctl函数可以对共享内存执行多种操作,根据参数 cmd 执行相应的操作。常用的是IPC_RMID(从系统中删除该共享内存)。
4.写入数据代码段
#include <sys/ipc.h>
#include <sys/shm.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
//int shmget(key_t key, size_t size, int shmflg);
int main()
{
int shmId;
key_t key;
key = ftok(".",1);
char *shmaddr;
shmId = shmget(key,1024 * 4,IPC_CREAT|0666);
if(shmId == -1){
printf("创建共享内存失败!\n");
exit(0);
}
shmaddr = shmat(shmId,0,0);
printf("映射完成!\n");
strcpy(shmaddr,"i am handsome");
sleep(5);
shmdt(shmaddr);
shmctl(shmId,IPC_RMID,0);
printf("结束!\n");
return 0;
}
读取数据代码段
#include <sys/ipc.h>
#include <sys/shm.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
//int shmget(key_t key, size_t size, int shmflg);
int main()
{
int shmId;
key_t key;
key = ftok(".",1);
char *shmaddr;
shmId = shmget(key,1024 * 4,0);
if(shmId == -1){
printf("创建共享内存失败!\n");
exit(0);
}
shmaddr = shmat(shmId,0,0);
printf("映射完成!\n");
printf("读取到的数据是:%s\n",shmaddr);
sleep(5);
shmdt(shmaddr);
shmctl(shmId,IPC_RMID,0);
printf("结束!\n");
return 0;
}
运行结果:
六、信号
对于 Linux来说,实际信号是软中断,许多重要的程序都需要处理信号。信号,为 Linux 提供了一种处理异步事件的方法。比如,终端用户输入了 ctrl+c 来中断程序,会通过信号机制停止一个程序。
1.信号的名字和编号:
a)每个信号都有一个名字和编号,这些名字都以“SIG”开头,例如“SIGIO ”、“SIGCHLD”等等。
b)信号定义在signal.h头文件中,信号名都定义为正整数。
c)具体的信号名称可以使用kill -l来查看信号的名字以及序号,信号是从1开始编号的,不存在0号信号。kill对于信号0又特殊的应用。
2.信号的处理:
信号的处理有三种方法,分别是:忽略、捕捉和默认动作
1)忽略信号,大多数信号可以使用这个方式来处理,但是有两种信号不能被忽略(分别是 SIGKILL和SIGSTOP)。因为他们向内核和超级用户提供了进程终止和停止的可靠方法,如果忽略了,那么这个进程就变成了没人能管理的的进程,显然是内核设计者不希望看到的场景。
2)捕捉信号,需要告诉内核,用户希望如何处理某一种信号,说白了就是写一个信号处理函数,然后将这个函数告诉内核。当该信号产生时,由内核来调用用户自定义的函数,以此来实现某种信号的处理。
3)系统默认动作,对于每个信号来说,系统都对应由默认的处理动作,当发生了该信号,系统会自动执行。不过,对系统来说,大部分的处理方式都比较粗暴,就是直接杀死该进程。
具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。
- 其实对于常用的 kill 命令就是一个发送信号的工具,kill 9 PID来杀死进程。比如,我在后台运行了一个 top 工具,通过 ps 命令可以查看他的 PID,通过 kill 9 来发送了一个终止进程的信号来结束了 top 进程。如果查看信号编号和名称,可以发现9对应的是 9) SIGKILL,正是杀死该进程的信号。而以下的执行过程实际也就是执行了9号信号的默认动作——杀死进程
3.信号处理函数的注册
信号处理函数的注册不只一种方法,分为入门版和高级版
入门版:函数signal
高级版:函数sigaction
4.信号处理发送函数
信号发送函数也不止一个,同样分为入门版和高级版
入门版:kill
高级版:sigqueue
5.函数原型:
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
根据函数原型可以看出由两部分组成,一个是真实处理信号的函数,另一个是注册函数了。
对于sighandler_t signal(int signum, sighandler_t handler);函数来说,signum显然是信号的编号,handler 是中断函数的指针。
同样,typedef void (*sighandler_t)(int);中断函数的原型中,有一个参数是 int 类型,显然也是信号产生的类型,方便使用一个函数来处理多个信号。
6.捕捉信号编程
#include <signal.h>
#include<stdio.h>
#include<stdlib.h>
/* typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);*/
void handler(int signum)
{
printf("捕捉到的信号值是:%d\n",signum);
switch(signum){
case 2:
printf("信号是:SIGINT\n");
break;
case 9:
printf("信号是:SIGKILL\n");
break;
case 10:
printf("信号是:SIGUSR1\n");
break;
}
printf("指令调用被捕捉,调用失败!\n ");
}
int main()
{
signal(SIGINT,handler);
signal(SIGKILL,handler);
signal(SIGUSR1,handler);
while(1);
return 0;
}
运行结果:
注意:
- 通过signal函数注册了一个信号处理函数,分别注册了三个信号,通过while循环维持这一进程。在信号处理函数捕捉这些信号,更改这些信号的默认处理方式。
比如我们直接在终端上输入Crt + C 即发送了SIGINT信号,按照SIGINT默认处理方式是结束这一进程,但它的默认处理已经被我们更改了,则进程不会退出。但值得注意的是,SIGKILL并不会被我们更改。
7.通过程序发送信号编程
#include <signal.h>
#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
// int kill(pid_t pid, int sig);
int main(int argc,char **argv)
{
int sig; //还一种方法,调用system函数实现
int pid; // char cmd[128] = {0};
sig = atoi(argv[1]);
pid = atoi(argv[2]);
printf("sig = %d pid = %d\n",sig,pid);
kill(pid,sig); //sprintf(cmd,"kill -%d %d",sig,pid);
printf("信号发送成功!\n"); //system(cmd);
return 0;
}
运行结果:
七、信号携带消息
1.sigaction 的函数原型
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
struct sigaction {
void (*sa_handler)(int); //信号处理程序,不接受额外数据,SIG_IGN 为忽略,SIG_DFL 为默认动作
void (*sa_sigaction)(int, siginfo_t *, void *); //信号处理程序,能够接受额外数据和sigqueue配合使用
sigset_t sa_mask;//阻塞关键字的信号集,可以再调用捕捉函数之前,把信号添加到信号阻塞字,信号捕捉函数返回之前恢复为原先的值。
int sa_flags;//影响信号的行为SA_SIGINFO表示能够接受数据
};
//回调函数句柄sa_handler、sa_sigaction只能任选其一
在函数原型中,第一个参数signum应该就是注册的信号的编号;
第二个参数act如果不为空说明需要对该信号有新的配置;
第三个参数oldact如果不为空,那么可以对之前的信号配置进行备份,以方便之后进行恢复。
1)struct sigaction结构体中的 sa_handler不携带数据,作用与入门版类似。
2)struct sigaction结构体中的 sa_mask 默认情况下在捕捉函数调用前为阻塞。
3)struct sigaction结构体中的 sa_flags 常设置为SA_SIGINFO,表式能够获取数据,说明了信号处理程序带有附加信息,也就是会调用 sa_sigaction 这个函数指针所指向的信号处理函数。否则,系统会默认使用 sa_handler 所指向的信号处理函数。
注意:
- sa_sigaction 和 sa_handler 使用的是同一块内存空间,相当于 union,所以只能设置其中的一个,不能两个都同时设置。
2.struct siginfo结构体说明
void (* sa_sigaction)(int signum,siginfo_t * info,void * ucontext);
void * 是接收到信号所携带的额外数据;而struct siginfo这个结构体主要适用于记录接收信号的一些相关信息。
siginfo_t {
int si_signo; /* Signal number */
int si_errno; /* An errno value */
int si_code; /* Signal code */
int si_trapno; /* Trap number that caused
hardware-generated signal
(unused on most architectures) */
pid_t si_pid; /* Sending process ID */
uid_t si_uid; /* Real user ID of sending process */
int si_status; /* Exit value or signal */
clock_t si_utime; /* User time consumed */
clock_t si_stime; /* System time consumed */
sigval_t si_value; /* Signal value */
int si_int; /* POSIX.1b signal */
void *si_ptr; /* POSIX.1b signal */
int si_overrun; /* Timer overrun count; POSIX.1b timers */
int si_timerid; /* Timer ID; POSIX.1b timers */
void *si_addr; /* Memory location which caused fault */
int si_band; /* Band event */
int si_fd; /* File descriptor */
}
其中的成员很多,si_signo 和 si_code 是必须实现的两个成员。可以通过这个结构体获取到信号的相关信息。
关于发送过来的数据是存在两个地方的,sigval_t si_value这个成员中有保存了发送过来的信息;
同时,在si_int或者si_ptr成员中也保存了对应的数据。
接收端代码:
#include <signal.h>
#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <unistd.h>
/* int sigaction(int signum, const struct sigaction *act,
struct sigaction *oldact);*/
void handler(int signum, siginfo_t *info, void *context)
{
printf("get signum = %d\n",signum);
if(context != NULL){
printf("get data = %d\n",info->si_int);
printf("from id:%d\n",info->si_pid);
printf("get message is:%d\n",info->si_value.sival_int);
}
}
int main()
{
struct sigaction act;
printf("my pid is:%d\n",getpid());
act.sa_sigaction = handler;
act.sa_flags = SA_SIGINFO;
sigaction(SIGUSR1,&act,NULL);
while(1);
return 0;
}
发送端代码:
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include<stdlib.h>
// int sigqueue(pid_t pid, int sig, const union sigval value);
/* union sigval
{
int sival_int;
void *sival_ptr;
};*/
int main(int argc, char **argv)
{
if(argc != 3){
printf("param error!\n");
}
int signum = atoi(argv[1]);
int pid = atoi(argv[2]);
union sigval value;
value.sival_int = 100;
sigqueue(pid,signum,value);
printf("my id is:%d\n",getpid());
return 0;
}
运行结果:
1)使用 sigaction 函数安装信号处理程序时,制定了 SA_SIGINFO 的标志。
2)sigaction 结构体中的 sa_sigaction 成员提供了信号捕捉函数。如果实现的时 sa_handler 成员,那么将无法获取额外携带的数据。
3)sigqueue 函数只能把信号发送给单个进程,可以使用 value 参数向信号处理程序传递整数值或者指针值。
4)sigqueue 函数不但可以发送额外的数据,还可以让信号进行排队(操作系统必须实现了 POSIX.1的实时扩展),对于设置了阻塞的信号,使用 sigqueue 发送多个同一信号,在解除阻塞时,接受者会接收到发送的信号队列中的信号,而不是直接收到一次。
- 但是,信号不能无限的排队,信号排队的最大值受到SIGQUEUE_MAX的限制,达到最大限制后,sigqueue 会失败,errno 会被设置为 EAGAIN。
八、信号量
1.什么是信号量?
信号量(semaphore)与已经介绍过的 IPC 结构不同,它是一个计数器。信号量用于实现进程间的互斥与同步,而不是用于存储进程间通信数据。
2.特点
1)信号量用于进程间同步,若要在进程间传递数据需要结合共享内存。
2)信号量基于操作系统的 PV 操作,程序对信号量的操作都是原子操作。
3)每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1,而且可以加减任意正整数。
4)支持信号量组。
3.原型
最简单的信号量是只能取 0 和 1 的变量,这也是信号量最常见的一种形式,叫做二值信号量(Binary Semaphore)。
而可以取多个正整数的信号量被称为通用信号量。
Linux 下的信号量函数都是在通用的信号量数组上进行操作,而不是在一个单一的二值信号量上进行操作。
#include <sys/sem.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, ...);
当semget创建新的信号量集合时,必须指定集合中信号量的个数(即num_sems),通常为1;
如果是引用一个现有的集合,则将num_sems指定为 0 。
在semop函数中,sembuf结构的定义如下:
struct sembuf
{
short sem_num; // 信号量组中对应的序号,0~sem_nums-1
short sem_op; // 信号量值在一次操作中的改变量
short sem_flg; // IPC_NOWAIT, SEM_UNDO
}
其中 sem_op 是一次操作中的信号量的改变量:
1)若sem_op > 0,表示进程释放相应的资源数,将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量,则换行它们。
2)若sem_op < 0,请求 sem_op 的绝对值的资源。
如果相应的资源数可以满足请求,则将该信号量的值减去sem_op的绝对值,函数成功返回。
当相应的资源数不能满足请求时,这个操作与sem_flg有关。
a)sem_flg 指定IPC_NOWAIT,则semop函数出错返回EAGAIN。
b)sem_flg 没有指定IPC_NOWAIT,则将该信号量的semncnt值加1,然后进程挂起直到下述情况发生:
当相应的资源数可以满足请求,此信号量的semncnt值减1,该信号量的值减去sem_op的绝对值。成功返回;
此信号量被删除,函数smeop出错返回EIDRM;
进程捕捉到信号,并从信号处理函数返回,此情况下将此信号量的semncnt值减1,函数semop出错返回EINTR
3.在semctl函数中的命令有多种,这里就说两个常用的:
a)SETVAL:用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
b)IPC_RMID:删除一个信号量集合。如果不删除信号量,它将继续在系统中存在,即使程序已经退出,它可能在你下次运行此程序时引发问题,而且信号量是一种有限的资源。
4.代码段
#include <sys/ipc.h>
#include <sys/sem.h>
#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <unistd.h>
//int semget(key_t key, int nsems, int semflg);
//int semctl(int semid, int semnum, int cmd, ...);
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 pgetkey(int id)
{
struct sembuf set;
set.sem_num = 0;
set.sem_op = -1;
set.sem_flg = SEM_UNDO;
semop(id,&set,1);
printf("get key\n");
}
void vputbackkey(int id)
{
struct sembuf set;
set.sem_num = 0;
set.sem_op = 1;
set.sem_flg = SEM_UNDO;
semop(id,&set,1);
printf("put back key\n");
}
int main()
{
key_t key;
key = ftok(".",2);
int semid; //信号量集合中有一个信号量
semid = semget(key,1,IPC_CREAT|0666);//获取/创建信号量
union semun initsem;
initsem.val = 0;
//操作第0个信号量
semctl(semid,0,SETVAL,initsem);//初始化信号量
//STVAL设置信号量的值,设置为initsem
int pid = fork();
if(pid >0 ){
pgetkey(semid);
printf("欢迎来到父进程!\n");
vputbackkey(semid);
semctl(semid,0,IPC_RMID);
}else if(pid == 0){
printf("欢迎来到子进程!\n ");
vputbackkey(semid);
}else{
printf("fork error");
}
return 0;
}
运行结果:
上面的例子如果不加信号量,则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。