进程间通信 （IPC）
进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。
IPC的方式通常有管道（无名管道）、FIFO（命名管道）、消息队列、共享内存、信号量、信号等。
一、管道
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。
1、特点：
它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
2、原型：
#include <unistd.h>
int pipe(int fd[2]); // 返回值：若成功返回0，失败返回-1
当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。如下图：
要关闭管道只需将这两个文件描述符关闭即可。close(fd[0]),close(fd[1])
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
int fd[2];
int pid;
char buf[128];
int status;
if(pipe(fd) == -1){ //创建管道
printf("creat pipe failed\n");
}
pid = fork();//创建管道成功后，创建进程
if(pid < 0){
printf("creat child failed\n");
}else if(pid > 0){ //父进程
printf("this is father\n");
close(fd[0]); //父进程执行写操作，先关闭读fd[0]
write(fd[1], "hello", strlen("hello"));
wait(&status);//等待子进程
}else{ //子进程
printf("this is child\n");
close(fd[1]);//子进程执行读操作
read(fd[0], buf, 128);
printf("from father data:%s\n", buf);
exit(0);
}
return 0;
}
运行结果：
ltk@ubuntu:~/06.30$ vi demo1.c
ltk@ubuntu:~/06.30$ gcc demo1.c
ltk@ubuntu:~/06.30$ ./a.out
this is father
this is child
from father data:hello
二、FIFO
FIFO，也称为命名管道，它是一种文件类型
1、特点
FIFO可以在无关的进程之间交换数据，与无名管道不同。
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
2、原型
#include <sys/stat.h>
// 返回值：成功返回0，出错返回-1
int mkfifo(const char *pathname, mode_t mode);
pathname：
文件路径
mode：
读写权限，0600可读可写
一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它
当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：
若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。
FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且“先进先出”。下面的例子演示了使用 FIFO 进行 IPC 的过程：
read.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
int main()
{
char buf[30]={0};
if(mkfifo("./06.30", 0600) == -1 && errno != EEXIST){
printf("mkfifo failed\n");
}
int fd = open("./06.30", O_RDONLY);
printf("open success\n");
int nread = read(fd, buf, 30);
printf("read %d byte,data:%s\n", nread, buf);
close(fd);
return 0;
}
write.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
int main()
{
char *str= "hello";
int fd;
fd = open("./06.30", O_WRONLY);
printf("write success\n");
write(fd, str, strlen(str));
close(fd);
return 0;
}
运行结果：
ltk@ubuntu:~/06.30$ ./read
open success
read 5 byte,data:hello
ltk@ubuntu:~/06.30$ ./write
write success
上述例子可以扩展成 客户进程—服务器进程 通信的实例，write_fifo的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，read_fifo类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：
三、消息队列
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。
1、特点
消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
2原型
#include <sys/msg.h>
int msgget(key_t key, int flag);// 创建或打开消息队列：成功返回队列ID，失败返回-1
int msgsnd(int msqid, const void *ptr, size_t size, int flag); // 添加消息：成功返回0，失败返回-1
int msgrcv(int msqid, void *ptr, size_t size, long type,int flag); // 读取消息：成功返回消息数据的长度，失败返回-1
int msgctl(int msqid, int cmd, struct msqid_ds *buf);// 控制消息队列：成功返回0，失败返回-1
// 缓存区 消息结构，定义消息结构，可以方便的定义参数ptr，long type
struct msgbuf {
long mtype;//消息类型
char mtext[256];//消息内容
};
1)int msgget(key_t key, int flag);
创建或获取消息队列：成功返回队列ID，失败返回-1；
key 值是双方规定一致的值，可以使用ftok()函数自动获取
flag ---IPC_CREAT|0777没有队列就创建队列，可读可写0777
int msgid = msgget(0x1234, IPC_CREAT|0777);
2_int msgsnd(int msqid, const void *ptr, size_t size, int flag);
发送消息队列：成功返回0，失败返回-1
msqid:创建或获取到的msgget的消息队列ID
ptr: 发送消息的缓存区，取得是地址，&sendbuf (struct msgbuf sendbuf = {888，"message from que"})
size: 消息内容的大小，strlen(sendbuf.mtext)
flag: 0的话，采用默认设置
msgsnd(msgid, &sendbuf, strlen(sendbuf.mtext), 0);
3)int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
读取消息：成功返回消息数据的长度，失败返回-1
msqid:创建或获取到的msgget的消息队列ID
ptr: 读取消息的缓存区，取得是地址，&readbuf （struct msgbuf readbuf）
size：消息内容的大小，sizeof(readbuf.mtext)**注意strlen(readbuf.mtext)会出现乱码
type: 消息队列的类型，读写双方一致的类型，888
falg： 0的话，采用默认设置
msgrcv如果读不到888类型的话会一直阻塞，指导读到
msgrcv(msgid, &readbuf, strlen(readbuf.mtext), 888, 0);
4)int msgctl(int msqid, int cmd, struct msqid_ds *buf);
控制消息队列：成功返回0，失败返回-1
msqid:创建或获取到的msgget的消息队列ID
cmd：IPC_RMID 移除消息队列
struct msqid_ds *buf: 一般设置为NULL
msgctl(msgid, IPC_RMID, NULL);
3、例子
下面写了一个简单的使用消息队列进行IPC的例子，服务端程序一直在等待特定类型的消息，直到收到该类型的消息。
get.c 服务器阻塞，直到接收到client data:hello客户端内容
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct msgbuf{
long mtype;
char mtext[128];
};
int main()
{
int msgid;
struct msgbuf readBuf;
key_t key;
key=ftok(".", 1);//自动获取key
printf("key = %x\n", key);
msgid = msgget(key, IPC_CREAT|0777);
if(msgid == -1){
printf("creat mag failed\n");
}
msgrcv(msgid, &readBuf, sizeof(readBuf.mtext), 988, 0);
printf("receive data :%s\n", readBuf.mtext);
msgctl(msgid, IPC_RMID, NULL);//移除消息队列
return 0;
}
write.c客户端发送client data:hello内容
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct msgbuf{
long mtype;
char mtext[238];
};
int main()
{
int msgid;
struct msgbuf sendBuf ={988, "client data:hello"};
key_t key;
key=ftok(".", 1);//自动获取key
printf("key = %x\n", key);
msgid = msgget(key, IPC_CREAT|0777);
if(msgid == -1){
printf("creat que falied\n");
}
msgsnd(msgid, &sendBuf, strlen(sendBuf.mtext), 0);
msgctl(msgid, IPC_RMID, NULL);//移除消息队列
return 0;
}
四、共享内存
共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。
1、特点
共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
因为多个进程可以同时操作，所以需要进行同步。
信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
2、原型
#include <sys/shm.h>
int shmget(key_t key, size_t size, int flag);// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
void *shmat(int shm_id, const void *addr, int flag);// 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
int shmdt(void *addr); // 断开与共享内存的连接：成功返回0，失败返回-1
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);// 控制共享内存的相关信息：成功返回0，失败返回-1
1)int shmget(key_t key, size_t size, int shmflag);
创建或获取一个共享内存：成功返回共享内存ID，失败返回
key 值是双方规定一致的值，可以使用ftok()函数自动获取
size :开辟空间大小，1024*4 单位以M对齐
shmflag: IPC_CREAT|0666 创建共享内存，并赋予权限可读可写
返回值：成功返回共享内存ID，失败返回-1
int shmid;
shmid = shmget(key, 1024*4, IPC_CREAT|0666);
2)void *shmat(int shmid, const void *addr, int shmflag);
连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
shmid： 共享内存ID
const void *addr: 一般为0，让内存自动分配
flag：一般也为0，设置为可读可写
char *shmaddr;
shmaddr = shmat(shmid, 0, 0);
3)int shmdt(void *addr);
断开与共享内存的连接：成功返回0，失败返回-1
addr：指向共享内存的指针，shmaddr
4）int shmctl(int shmid, int cmd, struct shmid_ds *buf);
控制共享内存的相关信息：成功返回0，失败返回-1
shmid 共享内存ID
cmd 命令IPC_RMID删除消息队列
buf 卸载共享内存的缓存信息，不关系就给予0
当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。
当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。
shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。
shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）。
3、例子
shmwrite.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <string.h>
#include <unistd.h>
int main()
{
int shmid;
key_t key;
char *shmaddr;
key = ftok(".", 1);
shmid = shmget(key, 1024*4, IPC_CREAT|0666);
shmaddr = shmat(shmid, 0, 0);
printf("shmat ok\n");
strcpy(shmaddr, "kangxiansen");
sleep(5);
shmdt(shmaddr);
shmctl(shmid, IPC_RMID, 0);
return 0;
}
shmread.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <string.h>
#include <unistd.h>
int main()
{
int shmid;
key_t key;
char *shmaddr;
key = ftok(".", 1);
shmid = shmget(key, 1024*4, 0);
if(shmid == -1){
printf("shmget failed\n");
exit(-1);
}
shmaddr = shmat(shmid, 0, 0);
printf("shmat ok\n");
printf("data:%s\n", shmaddr);
shmdt(shmaddr);
printf("quit\n");
return 0;
}
运行结果
ltk@ubuntu:~/06.30$ ./write
shmat ok
ltk@ubuntu:~/06.30$ ./read
shmat ok
data:kangxiansenquit
五、信号
对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c 来中断程序，会通过信号机制停止一个程序。
信号概述
1、信号的名字和编号：
每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。信号定义在signal.h头文件中，信号名都定义为正整数。具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用。
2、信号的处理：
信号的处理有三种方法，分别是：忽略、捕捉和默认动作
忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是 SIGKILL和SIGSTOP）。因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的的进程，显然是内核设计者不希望看到的场景
捕捉信号，需要告诉内核，用户希望如何处理某一种信号，说白了就是写一个信号处理函数，然后将这个函数告诉内核。当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号的处理。
系统默认动作，对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。
具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。
其实对于常用的 kill 命令就是一个发送信号的工具，kill -9 +pid进程pid号可以通过ps -aux|grep 进程名查看pid来杀死进程。
比如，我在后台运行了一个 top 工具，通过 ps 命令可以查看他的 PID，通过 kill 9 来发送了一个终止进程的信号来结束了 top 进程。如果查看信号编号和名称，可以发现9对应的是 9) SIGKILL，正是杀死该进程的信号
ltk@ubuntu:~/06.30$ ./top
Killed
ltk@ubuntu:~/06.30$ ps -aux|grep top
ltk 2057 0.0 1.5 1443044 30948 tty2 Sl+ Jun28 0:21 nautilus-desktop
ltk 60135 98.6 0.0 4380 868 pts/1 R+ 19:34 0:21 ./top
ltk 60138 0.0 0.0 14432 1092 pts/0 S+ 19:35 0:00 grep --color=auto top
ltk@ubuntu:~/06.30$ kill -9 60135//kill -SIGKILL 60135
信号处理函数
信号处理函数的注册不只一种方法，分为入门版和高级版
入门版：函数 signal
高级版：函数 sigaction
信号处理发送函数
信号发送函数也不止一个，同样分为入门版和高级版
1.入门版：kill
2.高级版：sigqueue
信号处理函数（入门）
signal 的函数原型
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
1）typedef void (*sighandler_t)(int);
函数指针，无返回值，参数是整型
2）sighandler_t signal(int signum, sighandler_t handler);
signum:信号，要捕捉的信号，可用kill -l查看
sighandler_t handler: 上述的函数指针
3.例子
捕捉信号，键盘按下Ctrl+C不能杀死程序
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
void handler(int signum)
{
printf("signum = %d\n", signum);
switch(signum){
case 2:
printf("SIGINT\n");//捕捉到SIGINT信号，打印
break;
case 9:
printf("SIGKILL\n");
break;
case 10:
printf("SIGUSR1\n");
break;
}
}
int main()
{
signal(SIGINT, handler);//捕捉信号，改变默认动作，调用自己定义的函数
//signal(SIGINT, SIG_IGN) SIG_IGN忽略命令的宏
signal(SIGKILL, handler);//但是SIGKILL和SIGSTOP这两种不能忽略
signal(SIGUSR1, handler);
while(1);
return 0;
}
运行结果：
ltk@ubuntu:~/06.30$ ps -aux|grep a.out
ltk 60544 101 0.0 4512 728 pts/1 R+ 23:21 0:24 ./a.out
ltk 60549 0.0 0.0 14432 1016 pts/0 S+ 23:21 0:00 grep --color=auto a.out
ltk@ubuntu:~/06.30$ kill -10 60544//kill不是杀死程序，是查询
ltk@ubuntu:~/06.30$ kill -2 60544
ltk@ubuntu:~/06.30$ kill -9 60544//SIGKILL不能被忽略
ltk@ubuntu:~/06.30$ ./a.out
signum = 10
SIGUSR1
signum = 2
SIGINT
Killed
kill 的函数原型
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
pid:就是接受者的 pid，
sig:是发送的信号的类型
#include <sys/types.h>
#include <signal.h>
#include<stdio.h>
#include <unistd.h>
int main(int argc, char** argv)
{
int pid = atoi(argv[1]);
int sig = atoi(argv[2]);
if(pid > 0 && sig > 0)
{
kill(pid, sig);
}
else{
printf("Target_PID or Signal_Number MUST bigger than 0!\n");
}
return 0;
}
关于 kill 函数，还有一点需要额外说明，上面的程序限定了 pid 必须为大于0的正整数，其实 kill 函数传入的 pid 可以是小于等于0的整数。
pid > 0：将发送个该 pid 的进程
pid == 0：将会把信号发送给与发送进程属于同一进程组的所有进程，并且发送进程具有权限想这些进程发送信号。
pid < 0：将信号发送给进程组ID 为 pid 的绝对值得，并且发送进程具有权限向其发送信号的所有进程
pid == -1：将该信号发送给发送进程的有权限向他发送信号的所有进程。（不包括系统进程集中的进程）
信号注册处理函数（高级）
sigaction 的函数原型
#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
signum:注册的信号的编号，可用kill -l查看
act: 如果不为空说明需要对该信号有新的配置,想做什么
oldact:如果不为空，那么可以对之前的信号配置进行备份，以方便之后进行恢复。设置NULL
const struct sigaction *act
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表示能够接受数据
};
void (*sa_sigaction)(int, siginfo_t *, void *);
例：void handler(int signum, siginfo_t *info, void *context)
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 */
}
信号发送函数——高级版
#include <signal.h>
int sigqueue(pid_t pid, int sig, const union sigval value);
value：发送的内容，value.sival_int
union sigval {
int sival_int;//发送整型数据
void *sival_ptr;//发送字符串
};
接收端
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
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("get data = %d\n", info->si_value.sival.int);//也是取数据
printf("from pid:%d", info->si_pid);//发送者pid
}
}
int main()
{
struct sigaction act;//想做什么，处理信号
printf("pid = %d", getpid());//获取pid
act.sa_sigaction = handler;//读数据
act.sa_flags = SA_SIGINFO;//能够接收信号
sigaction(SIGUSR1, &act, NULL);//注册信号
while(1);
return 0;
}
发送端
#include <stdio.h>
#include <signal.h>
int main(int argc, char **argv[])
{
int signum;
int pid;
signum = atoi(argv[1]);
pid = atoi(argv[2]);
union sigval value;
value.sival_int = 100;
sigqueue(pid, signum, value);//
printf("%d, done\n", getpid());
return 0;
}
运行结果：
ltk@ubuntu:~/06.30$ ./send 10 61693
61697, done
ltk@ubuntu:~/06.30$ ./receive
pid = 61693
get signum 10
get data = 100
from pid 61697
六、信号量
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
临界资源：多道程序系统中存在许多进程，它们共享各种资源，然而有很多资源一次只能供一个进程使用。一次仅允许一个进程使用的资源称为临界资源。许多物理设备都属于临界资源，如输入机、打印机、磁带机等
信号量集：信号量集，是一种计算机用语，用于各进程之间发送的消息。
P操作：PV操作与信号量的处理相关，P表示通过的意思，
V操作：V表示释放的意思
1、特点
信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
支持信号量组。
2、原型
最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。
Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作
#include <sys/sem.h>
int semget(key_t key, int num_sems, int sem_flags);//创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
int semop(int semid, struct sembuf semoparray[], size_t numops); //对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
int semctl(int semid, int sem_num, int cmd, ...);// 控制信号量的相关信息
1)int semget(key_t key, int num_sems, int sem_flags);
key：调用ftok()函数获得
num_sems：信号量集中信号量的个数，通常为1
sem_flags：获取信号量，如果没有就创建IPC_CREAT|0666
返回值：信号量集ID int semid
2)int semop(int semid, struct sembuf *sops, size_t nsops);
在semop函数中，sembuf结构的定义如下：
struct sembuf
{
short sem_num; // 信号量组中对应的序号，0～sem_nums-1
short sem_op; // 信号量值在一次操作中的改变量，相当于取钥匙还是放钥匙
short sem_flg; // SEM_UNDO
}
nsops：sops数组的个数，一个就为1
3)int semctl(int semid, int sem_num, int cmd, ...)
semid 信号量集ID
sem_num 设置信号量集中的第几个信号量
cmd 控制命令 ，SETVAL 设置信号量的值
在semctl函数中的命令有多种，这里就说两个常用的：
SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
参数四；类型必须是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) */
};
3、例子
如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
union semun {//联合体，用于semctl初始化
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)//p操作，若信号量值为1，获取资源并将信号量值-1 ，若信号量值为0，进程挂起等待，可以理解为拿钥匙
{
struct sembuf set;
set.sem_num = 0;//信号量的序号
set.sem_op = -1;//拿钥匙，原来的钥匙减1
set.sem_flg = SEM_UNDO;//等待
semop(id, &set, 1);
printf("getkey\n");
}
void vPutBackKey(int id)//v操作，理解为放回钥匙，释放资源并将信号量值+1，如果有进程正在挂起等待，则唤醒它们
{
struct sembuf set;
set.sem_num = 0;
set.sem_op = 1;//放回钥匙，原来的钥匙加1
set.sem_flg = SEM_UNDO;
semop(id, &set, 1);
printf("backkey\n");
}
int main()
{
key_t key;
key = ftok(".", 1);
int semid;
union semun initsem;
initsem.val = 0;//初值设为0资源被占用，理解为钥匙被人拿走了
semid = semget(key, 1, IPC_CREAT|0666);//信号量集合中只有一个信号量
semctl(semid, 0, SETVAL, initsem);//操作第0个信号量，初始化设置为initsem
int pid = fork();
if(pid > 0){
pGetKey(semid);//去拿钥匙，如果没有就阻塞在这里，直到被放回
printf("this is father\n");
vPutBackKey(semid);//放回钥匙
semctl(semid, 0, IPC_RMID);//删除信息量
}else if(pid == 0){
printf("this is child\n");//子进程先执行
vPutBackKey(semid);//放回钥匙
}else{
printf("fork failed\n");
}
return 0;
}
9739
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
