进程间的通信方式
无名管道
管道是UNIX IPC的最老形式，并且所有UNIX系统都提供此种通信机制，管道有两种限制；
(1) 它们是半双工的。数据只能在一个方向上流动。
(2) 它们只能在具有公共祖先的进程之间使用。通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
原型：
#include <unistd.h> //头文件
int pipe(int filefd[2]) ;
返回：若成功则为0，若出错则为- 1
经由参数filefd返回两个文件描述符：filefd[0]为读而打开，filefd[1]为写而打开。filefd[1]的输出是filefd[0]的输入。
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <string.h>
int main(){
int fd[2];
pid_t pid;
char *buf = "clc handsome";
char readbuf[64] = {'\0'};
int n_read;
if(-1 == pipe(fd)){
perror("pipe");
}
pid = fork();
if(pid == 0){
close(fd[1]); //关闭写端
read(fd[0],readbuf,64);
printf("from father:%s\n",readbuf);
// exit(0);
}
if(pid > 0){
// wait(NULL);
close(fd[0]); //关闭读端
write(fd[1],buf,strlen(buf));
}
return 0;
}
结果：from father:clc handsome
这里可以看出无名管道限制于父子进程中，父子进程不能同时读或者写，数据只能单向流通，从上面的代码中可以看到父进程在争夺到CPU资源后先关闭读端管道，然后写；即使子进程先争夺到资源，因为管道没有数据会先发生阻塞无数据，然后由于阻塞父进程夺得资源，然后写入数据。
有名管道
FIFO有时被称为命名管道。管道只能由相关进程使用，它们共同的祖先进程创建了管道。但是，通过FIFO，不相关的进程也能交换数据。
原型：
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode) ; //创建一个有名管道
返回：若成功则为0，若出错则为- 1
mode参数的规格说明与open函数中的mode相同
一旦已经用mkfifo创建了一个FIFO，就可用open打开它。确实，一般的文件 I / O函数（close、read、write等）都可用于FIFO。
当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：
若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。
read.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(){
int fd;
char buf[30] = {'\0'};
if( (-1 == mkfifo("./file",0600)) && errno != EEXIST ){ //对file有读写权限（当前用户）
perror("mkfifo"); //在当前路径下创建名为file的有名管道
}
fd = open("./file",O_RDONLY);
if(fd == -1){
perror("open");
}
read(fd,buf,30);
printf("from file:%s\n",buf);
close(fd);
return 0;
}
write.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main(){
char *buf = "clc handsome";
if( (-1 == mkfifo("./file",0600)) && errno != EEXIST ){
perror("mkfifo");
}
int fd = open("./file",O_WRONLY);
write(fd,buf,strlen(buf));
close(fd);
return 0;
}
先运行read.c, open此file时设置了只读打开所以会先先阻塞（也就是上面说的），直到一个进程以只写方式打开此file有名管道，即write.c中的open打开是以只写方式打开。
消息队列
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。
1.消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
2.消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
3.消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
1 #include <sys/msg.h>
2 // 创建或打开消息队列：成功返回队列ID，失败返回-1
3 int msgget(key_t key, int flag);
4 // 添加消息：成功返回0，失败返回-1
5 int msgsnd(int msqid, const void *ptr, size_t size, int flag);
6 // 读取消息：成功返回消息数据的长度，失败返回-1
7 int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
8 // 控制消息队列：成功返回0，失败返回-1
9 int msgctl(int msqid, int cmd, struct msqid_ds *buf);
key_t ftok( char * fname, int id )
fname就时你指定的文件名，id是子序号,是int类型，但是只使用8bits(1-255）。
recview.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf{
long mtype;
char mtext[30];
};
int main(){
key_t key;
key = ftok(".",1); //获取一个key, 这样就是将fname设为当前目录。
//id是子序号。虽然是int类型，但是只使用8bits(1-255）。
printf("key = %d\n",key);
int msgId;
struct msgbuf rcvbuf;
msgId = msgget(key,IPC_CREAT|0777);
if(msgId == -1){
perror("msgget");
}
if( -1 == msgrcv(msgId,&rcvbuf,sizeof(rcvbuf.mtext),888,0) ){
perror("msgrcv");
}
printf("from sendbuf:%s\n",rcvbuf.mtext);
if( -1 == msgctl(msgId, IPC_RMID, 0) ){
perror("msgctl");
}
return 0;
}
send.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
struct msgbuf{
long mtype;
char mtext[30];
};
int main(){
key_t key;
key = ftok(".",1);
//获取一个key, 这样就是将fname设为当前目录。
//id是子序号。虽然是int类型，但是只使用8bits(1-255）。
printf("key = %d\n",key);
int msgId;
struct msgbuf sendbuf = {888, "clc handsome"};
msgId = msgget(key,IPC_CREAT|0777);
if(msgId == -1){
perror("msgget");
}
if( -1 == msgsnd(msgId,&sendbuf,sizeof(sendbuf.mtext),0) ){
perror("msgrcv");
}
printf("send success\n");
return 0;
}
msgsnd和msgrcv中的ptr都是一个指针，指向于一个结构体
ptr就是一个指向mymesg结构的指针。mtype是收发数据的类型，mtext是写入/读出消息队列的内容
如果msgrcv中ptr的mtype指定的数据类型是888，则msgsnd中ptr的mtype就要求是888，否则就接收不到，就是msgrcv首先判断数据类型是不是888，不是则不予接收，可以理解为是规定一种协议，接收双方的mtype必须一致。
其中flgs一般设为0.就是阻塞的意思了，没有msgsnd所在的进程发数据，msgrcv所在的接收进程则阻塞。
msgctl中cmd参数
cmd参数指定的几个宏：
• IPC_STAT 取此队列的m s q i d _ d s结构，并将其存放在b u f指向的结构中。
• IPC_SET 按由b u f指向的结构中的值，设置与此队列相关的结构中的下列四个字段：
m s g _ p e r m . u i d、m s g _ p e r m . g i d、m s g _ p e r m ; m o d e和m s g _ q b y t e s。此命令只能由下列两种进程执行：一种是其有效用户I D等于m s g _ p e r m . c u i d或m s g _ p e r m . u i d ;另一种是具有超级用户特权的进程。只有超级用户才能增加m s g _ q b y t e s的值
• IPC_RMID 从系统中删除该消息队列以及仍在该队列上的所有数据。这种删除立即生效。
仍在使用这一消息队列的其他进程在它们下一次试图对此队列进行操作时，将出错返回
E I D R M。此命令只能由下列两种进程执行：一种是其有效用户 I D等于m s g _ p e r m . c u i d或
m s g _ p e r m . u i d ;另一种是具有超级用户特权的进程。
一般是IPC_RMID,删除创建的消息队列中的内容。
共享内存
共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。
共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
因为多个进程可以同时操作，所以需要进行同步。
信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
1 #include <sys/shm.h>
2 // 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
3 int shmget(key_t key, size_t size, int flag);
4 // 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
5 void *shmat(int shm_id, const void *addr, int flag);
6 // 断开与共享内存的连接：成功返回0，失败返回-1
7 int shmdt(void *addr);
8 // 控制共享内存的相关信息：成功返回0，失败返回-1
9 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);
shmread.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
// int shmget(key_t key, size_t size, int shmflg);
// void *shmat(int shmid, const void *shmaddr, int shmflg);
// int shmdt(const void *shmaddr);
int main(){
int key;
int shmid;
char *shmaddr;
key = ftok(".",2);
shmid = shmget(key,1024,0);
if(shmid == -1){
perror("shmget");
}
shmaddr = shmat(shmid,0,0);
if(shmaddr == NULL){
printf("shmaddr error\n");
}
printf("form write:%s\n",shmaddr);
if( -1 == shmdt(shmaddr) ){
printf("shmdt error\n");
}
if(-1 == shmctl(shmid, IPC_RMID, 0) ){
printf("shmctl error\n");
}
return 0;
}
shmwrite.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
// int shmget(key_t key, size_t size, int shmflg);
// void *shmat(int shmid, const void *shmaddr, int shmflg);
// int shmdt(const void *shmaddr);
int main(){
int key;
int shmid;
char *shmaddr;
key = ftok(".",2);
shmid = shmget(key,1024,IPC_CREAT|0666);
if(shmid == -1){
perror("shmget");
}
shmaddr = shmat(shmid,0,0);
if(shmaddr == NULL){
printf("shmaddr error\n");
}
strcpy(shmaddr,"clc handsome");
if( -1 == shmdt(shmaddr) ){
printf("shmdt error\n");
}
return 0;
}
int shmget(key_t key, size_t size, int shmflg);
这里size必须是1024字节的倍数，即必须是以兆为单位
void *shmat(int shmid, const void *addr, int flg);
(1) 如果addr为0，则此段连接到由内核选择的第一个可用地址上。
(2) 如果addr非0，并且没有指定SHM_RND，则此段连接到addr所指定的地址上。
(3) 如果addr非0，并且指定了SHM_RND，则此段连接到（addr－(addr mod SHMLBA)）。
如果在flag中指定了SHM_RDONLY位，则以只读方式连接此段。否则以读写方式连接此段。
一般addr直接写0，让内核自己分配，flg也写0
返回的是一个地址，就是开辟出来的共享内存。
shmat的返回值是该段所连接的实际地址，如果出错则返回-1。
当对共享存储段的操作已经结束时，则调用shmdt脱接该段。
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);
c m d参数指定下列5种命令中一种，使其在s h m i d指定的段上执行。
• IPC_STAT 对此段取s h m i d _ d s结构，并存放在由b u f指向的结构中。
• IPC_SET 按 b u f指向的结构中的值设置与此段相关结构中的下列三个字段：
s h m _ p e r m . u i d、s h m _ p e r m . g i d以及s h m _ p e r m . m o d e。此命令只能由下列两种进程执行：一种是
其有效用户I D等于s h m _ p e r m . c u i d或s h m _ p e r m . u i d的进程；另一种是具有超级用户特权的进程。
• IPC_RMID 从系统中删除该共享存储段。（一般直接写这个）
（s h m _ n a t t c h在s h m i d _ d s结构中）,所以除非使用该段的最后一个进程终止或与该段脱接，否则不会实际上删除该存储段。不管此段是否仍在使用，该段标识符立即被删除 ,所以不能再用
s h m a t与该段连接。此命令只能由下列两种进程执行:一种是其有效用户I D等于s h m _ p e r m . c u i d或
s h m _ p e r m . u i d的进程；另一种是具有超级用户特权的进程。
struct shmid_ds *buf
一般这里就是存储删除共享内存后内存中的一些数据，一般也直接写0，就是NULL
ipcs -m 查看当前系统中的共享内存
ipcsrm -m xxx 手动删除shmid为xxx的共享内存
信号
对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c 来中断程序，会通过信号机制停止一个程序。
每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。
信号定义在signal.h头文件中，信号名都定义为正整数。
具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用。
信号的处理有三种方法，分别是：忽略、捕捉和默认动作
1.忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是 SIGKILL和SIGSTOP）。因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的的进程，显然是内核设计者不希望看到的场景。
2.捕捉信号，需要告诉内核，用户希望如何处理某一种信号，说白了就是写一个信号处理函数，然后将这个函数告诉内核。当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号的处理。
3.系统默认动作，对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。
具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。
其实对于常用的 kill 命令就是一个发送信号的工具，kill 9 PID来杀死进程。比如，我在后台运行了一个 top 工具，通过 ps 命令可以查看他的 PID，通过 kill 9 来发送了一个终止进程的信号来结束了 top 进程。如果查看信号编号和名称，可以发现9对应的是 9) SIGKILL，正是杀死该进程的信号。而以下的执行过程实际也就是执行了9号信号的默认动作——杀死进程
入门版
如上文所说，对于信号来说我们最关心的就是捕捉信号，对一个进程来说，当收到系统所发来的一个信号，可以根据收到的信号时处理自己想执行的函数。
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
// typedef void (*sighandler_t)(int);
// sighandler_t signal(int signum, sighandler_t handler);
void handler(int signum){
if(signum == SIGINT){
printf("you input sigint\n");
}
}
int main(){
signal(SIGINT, handler); //捕捉信号
while(1);
return 0;
}
当调用用signal捕捉到用户发来的SIGINT（就是ctrl+c,结束进程）时，执行自己想要执行的handler函数。这里就是忽略了来自系统的SIGINT的信号。
高级版
高级版就是可以收到来自于接收的信号所携带的数据。
sigaction例子（接收端）：
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
// int sigaction(int signum, const struct sigaction *act,
// struct sigaction *oldact);
/*
struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};
*/
void handler(int signum,siginfo_t *info, char *context){
if(context != NULL){
printf("you input SIGINT\n");
printf("get:%d\n",info->si_int);
}
}
int main(){
struct sigaction act;
act.sa_sigaction = (void *)handler;
act.sa_flags = SA_SIGINFO;
printf("my pid is %d\n",getpid());
sigaction(SIGINT, &act,NULL);
while(1);
return 0;
}
函数原型：
#include <signal.h>
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如果不为空，那么可以对之前的信号配置进行备份，以方便之后进行恢复。
- struct sigaction结构体中的 sa_handler不携带数据，作用与入门版类似。
- struct sigaction结构体中的 sa_mask 默认情况下在捕捉函数调用前为阻塞。
- struct sigaction结构体中的 sa_flags 常设置为SA_SIGINFO，表式能够获取数据，说明了信号处理程序带有附加信息，也就是会调用 sa_sigaction 这个函数指针所指向的信号处理函数。否则，系统会默认使用 sa_handler 所指向的信号处理函数。
注意：sa_sigaction 和 sa_handler 使用的是同一块内存空间，相当于 union，所以只能设置其中的一个，不能两个都同时设置。
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成员中也保存了对应的数据。
sigqueue例子（发送端）：
#include <stdio.h>
#include <signal.h>
// #include <signal.h>
// int sigqueue(pid_t pid, int sig, const union sigval value);
int main(int argc, char **argv){
int signum = atoi(argv[1]);
int pid = atoi(argv[2]);
union sigval valve;
valve.sival_int = 100;
sigqueue(pid, signum, valve);
return 0;
}
使用这个函数之前，必须要有几个操作需要完成
- 使用 sigaction 函数安装信号处理程序时，制定了 SA_SIGINFO 的标志。
- sigaction 结构体中的 sa_sigaction 成员提供了信号捕捉函数。如果实现的时 sa_handler 成员，那么将无法获取额外携带的数据。
sigqueue 函数不但可以发送额外的数据，还可以让信号进行排队（操作系统必须实现了 POSIX.1的实时扩展），对于设置了阻塞的信号，使用 sigqueue 发送多个同一信号，在解除阻塞时，接受者会接收到发送的信号队列中的信号，而不是直接收到一次。
但是，信号不能无限的排队，信号排队的最大值受到SIGQUEUE_MAX的限制，达到最大限制后，sigqueue 会失败，errno 会被设置为 EAGAIN。
这里信号相关内容参考的是：
https://blog.csdn.net/weixin_49001854/article/details/118461465
信号量
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
-
信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
-
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
-
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
-
支持信号量组。
原型：
最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。
Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。
1 #include <sys/sem.h>
2 // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
3 int semget(key_t key, int num_sems, int sem_flags);
4 // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
5 int semop(int semid, struct sembuf semoparray[], size_t numops);
6 // 控制信号量的相关信息
7 int semctl(int semid, int sem_num, int cmd, ...);
例子：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
// int semget(key_t key, int nsems, int semflg);
// int semctl(int semid, int semnum, int cmd, ...);
// int semop(int semid, struct sembuf *sops, unsigned nsops);
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 semid){ //申请资源
struct sembuf tmp;
tmp.sem_num = 0;
tmp.sem_op = -1;
tmp.sem_flg = SEM_UNDO;
semop(semid, &tmp, 1);
}
void vPutBackKey(int semid){ //释放资源
struct sembuf tmp;
tmp.sem_num = 0;
tmp.sem_op = 1;
tmp.sem_flg = SEM_UNDO;
semop(semid, &tmp, 1);
}
int main(){
int key;
union semun initsem;
int semid;
key = ftok(".",2);
if(-1 == (semid = semget(key, 1, IPC_CREAT|0666))){ //获取/创建一个信号量组
//该信号量组只有一个信号量
printf("semget error\n");
}
initsem.val = 0; //信号量初始值为0
//对信号量组(数组)的第一个信号量元素操作
semctl(semid, 0, SETVAL, initsem); //初始化信号量组
//设置信号量的值，设置为initsem中的值
int pid = fork();
if(pid == 0){
vPutBackKey(semid);
printf("this is child\n");
}
if(pid > 0){
pGetKey(semid);
printf("this is father\n");
}
return 0;
}
到这里想了解一下临界资源：
操作系统中存在许多进程，它们共享各种资源，然而有很多资源一次只能供一个进程使用。一次仅允许一个进程使用的资源称为临界资源。许多物理设备都属于临界资源，如输入机、打印机、磁带机等。
当一些临界资源被争夺时，信号量就是管控这些临界资源的。
例子中当fork之后假设父进程先争夺到CPU资源，会阻塞到pGetKey，因为父进程设置的信号量的值为0，只有当子进程先运行vPutBackKey释放临界资源，父进程得到临近资源才会结束阻塞。
在semop函数中，sembuf结构的定义如下：
struct sembuf
{
short sem_num; // 信号量组中对应的序号，0～sem_nums-1
short sem_op; // 信号量值在一次操作中的改变量
short sem_flg; // IPC_NOWAIT, SEM_UNDO
}
其中 sem_op 是一次操作中的信号量的改变量：
-
若sem_op > 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。
-
若sem_op < 0，请求 sem_op 的绝对值的资源。
如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。
当相应的资源数不能满足请求时，这个操作与sem_flg有关。
sem_flg 指定IPC_NOWAIT，则semop函数出错返回EAGAIN。
sem_flg 没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem_op的绝对值。成功返回；
此信号量被删除，函数smeop出错返回EIDRM；
进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR
若sem_op == 0，进程阻塞直到信号量的相应值为0：
当信号量已经为0，函数立即返回。
如果信号量的值不为0，则依据sem_flg决定函数动作：
sem_flg指定IPC_NOWAIT，则出错返回EAGAIN。
sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；
此信号量被删除，函数smeop出错返回EIDRM；
进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
在semctl函数中的命令有多种，这里就说两个常用的：
SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
2506
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
