进程间通信总结

2023/6/27  通信之间的实现，目的是为了，方便回顾时立马能使用。具体的比如什么情况选用什么通信，各自的优点，没有记录。原因是，本人目前实战经验较少，还处于学习状态，对此的理解还停留在管道方便，共享内存效率高，控制操作用消息队列

前提

• 进程间通信多少种？
  

答：7种，分别为无名管道、有名管道、信号、消息队列、共享内存、信号灯集、套接字

• 能简单说一下分别的特点吗？
  

答：

• 无名管道：只能用于情缘关系的进程间通信，半双工，固定读写端，看成特殊的文件，围绕文件描述符，fd[0]读，fd[1]写，遵循先进先出，通过文件IO来操作
  
• 有名管道：互不相关的进程互相通信，在文件系统可见，通过文件IO来操作，遵循先进先出，不支持lseek()操作
  
• 信号：软件层次上中断机制的模拟，异步通信，直接进行用户空间进程和内核进程间的交互。内核可以利用它来通知用户空间进程发送那些系统事件。
  
• 消息队列：是IPC对象的一种，由消息队列ID来唯一标识，是一个消息的列表，用户可以在消息队列中添加消息、读取消息。
  
• 共享内存：最为高效的进程间通信，进程可以直接读写内存，而不需要任何数据拷贝。进程直接读写内核开辟的内存区，不需要进行数据拷贝，但是因为多个进程共享一段内存，因此需要信号量和互斥锁来同步。
  
• 信号灯集：也叫信号量，不同进程或一个进程内部不同线程同步的机制
  
• 套接字：为网络编程的一种通信机制，因为通信的进程都是在一台计算机中，所以套接字也是一种进程间通信。
  

• 能对上面的进程通信用代码描叙一下吗？
  

答：如下所示
无名管道

函数接口

1. int pipe(int fd[2])
2. 功能：创建无名管道
3. 参数：文件描述符 fd[0]：读端  fd[1]:写端
4. 返回值：成功 0
5.       失败 -1

复制代码

注意事项

a.  当管道中无数据时，读操作会阻塞；
管道中无数据时，将写端关闭，读操作会立即返回
b. 管道中装满（管道大小64K）数据写阻塞，一旦有4k空间，写继续
c. 只有在管道的读端存在时，向管道中写入数据才有意义。否则，会导致管道破裂，向管道中写入数据的进程将收到内核传来的SIGPIPE信号  (通常Broken pipe错误)。
功能实现

父进程循环从终端输入字符串，子进程将字符串循环输出

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <unistd.h>
4. #include <stdlib.h>
5. #include <string.h>
6. #include <sys/wait.h>
10. int main(int argc, char const *argv[])
11. {
12.     char buf[32] = "";
13.     pid_t id;
14.     int fd[2] = {0};
15.     if(pipe(fd) < 0)
16.     {
17.         perror("pipe err");
18.         return -1;
19.     }
20.     if ((id = fork()) < 0)
21.     {
22.         perror("fork err");
23.         return -1;
24.     }
25.     else if (id == 0)//子进程
26.     {
27.         while(1)
28.         {
29.             char buf[32] = "";
30.             read(fd[0], buf, 32);
31.             if(strcmp(buf, "quit") == 0)
32.                 break;
33.             printf("buf:%s\n", buf);
34.         }
35.         exit(0);
36.     }
37.     else//父进程
38.     {
39.         while(1)
40.         {
41.             char buf[32] = "";
42.             // scanf("%s", buf);
43.             fgets(buf, 32, stdin);
44.             write(fd[1], buf, strlen(buf)+1);
45.             if(strcmp(buf, "quit") == 0)
46.                 break;
47.         }
48.         wait(NULL);
49.     }
52.     return 0;
53. }

复制代码

有名管道

函数接口

1. int mkfifo(const char *filename,mode_t mode);
2. 功能：创健有名管道
3. 参数：filename：有名管道文件名
4.        mode：权限
5. 返回值：成功：0
6.        失败：-1，并设置errno号
7. 注意对错误的处理方式：
8. 如果错误是file exist时，注意加判断，如：if(errno == EEXIST)

复制代码

注意事项

a. 只写方式，写阻塞，一直到另一个进程把读打开
b. 只读方式，读阻塞，一直到另一个进程把写打开
c. 可读可写，如果管道中没有数据，读阻塞
功能实现

读写操作

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <errno.h>
5. #include <unistd.h>
6. #include <string.h>
7. #include <fcntl.h>
10. int main(int argc, char const *argv[])
11. {
12.     int fd;
13.     //创建管道
14.     if (mkfifo("./fifo", 0666) < 0)
15.     {
16.         if (errno == EEXIST)
17.             printf("file exists\n");
18.         else
19.         {
20.             perror("mkfifo err");
21.             return -1;
22.         }
23.     }
24.     printf("mkfifo ok\n");
25.     //打开管道
26.     fd = open("./fifo", O_RDWR);
27.     if(fd < 0)
28.     {
29.         perror("open err");
30.         return -1;
31.     }
32.     char buf[32] = "hello";
33.     char data[32] = "";
34.     write(fd, buf, strlen(buf));
37.     read(fd, data, 32);
38.     printf("%s\n", data);
41.     return 0;
42. }

复制代码

信号

函数接口

1. int kill(pid_t pid, int sig);
2. 功能：信号发送
3. 参数：pid：指定进程
4.    sig：要发送的信号
5. 返回值：成功 0     
6.        失败 -1
7. int raise(int sig);
8. 功能：进程向自己发送信号
9. 参数：sig：信号
10. 返回值：成功 0   
11.        失败 -1
14. signal(SIGINT, SIG_IGN);//忽略信号
15. signal(SIGINT, SIG_DFL); //执行默认操作
16. signal(SIGINT, handler); //捕捉信号
17. void handler(int sig)//捕捉到该信号执行该函数操作
18. {
19.     printf("ctrl+c\n");
20. }

复制代码

注意事项

SIGKILL：结束进程，不能被忽略不能被捕捉
SIGSTOP：结束进程，不能被忽略不能被捕捉
SIGCHLD：子进程状态改变时给父进程发的信号,不会结束进程
SIGINT：结束进程，对应快捷方式ctrl+c
SIGTSTP：暂停信号，对应快捷方式ctrl+z
SIGQUIT：退出信号，对应快捷方式ctrl+
SIGALRM：闹钟信号，alarm函数设置定时，当到设定的时间时，内核会向进程发送此信号结束进程。
SIGTERM：结束终端进程，kill 使用时不加数字默认是此信号
功能实现

用信号的知识实现司机和售票员问题。
1）售票员捕捉SIGINT（代表开车）信号，向司机发送SIGUSR1信号，司机打印（let's gogogo）
2）售票员捕捉SIGQUIT（代表停车）信号，向司机发送SIGUSR2信号，司机打印（stop the bus）
3）司机捕捉SIGTSTP（代表到达终点站）信号，向售票员发送SIGUSR1信号，售票员打印（please get off the bus）
4）司机等待售票员下车，之后司机再下车。

1. #include <stdio.h>
2. #include <signal.h>
3. #include <unistd.h>
4. #include <stdlib.h>
5. #include <sys/types.h>
6. #include <sys/wait.h>
8. pid_t pid;
9. void driver(int sig)
10. {
11.     if (sig == SIGUSR1)
12.         printf("let's gogogo\n");
13.     else if (sig == SIGUSR2)
14.         printf("stop the bus\n");
15.     else if (sig == SIGTSTP)
16.     {
17.         kill(pid, SIGUSR1);
18.         wait(NULL);
19.         exit(0);
20.     }
21. }
22. void saler(int sig)
23. {
24.     if (sig == SIGINT)
25.         kill(getppid(), SIGUSR1);
26.     else if (sig == SIGQUIT)
27.         kill(getppid(), SIGUSR2);
28.     else if (sig == SIGUSR1)
29.     {
30.         printf("please get off the bus\n");
31.         exit(0);
32.     }
33. }
34. int main(int argc, char const *argv[])
35. {
36.     if ((pid = fork()) < 0)
37.     {
38.         perror("fork err");
39.         return -1;
40.     }
41.     else if (pid == 0)
42.     {
43.         signal(SIGINT, saler);
44.         signal(SIGQUIT, saler);
45.         signal(SIGUSR1, saler);
46.         signal(SIGTSTP, SIG_IGN);
47.     }
48.     else
49.     {
50.         signal(SIGUSR1, driver);
51.         signal(SIGUSR2, driver);
52.         signal(SIGTSTP, driver);
53.         signal(SIGINT, SIG_IGN);
54.         signal(SIGQUIT, SIG_IGN);
55.     }
56.     while (1)
57.         pause();
59.     return 0;
60. }

复制代码

消息队列

函数接口

1. 步骤：
2. 1）创建key值  ftok
3. 2）创建或打开消息队列  msgget  
4. 3）添加消息/读取消息   msgsnd/msgrcv
5. 4）删除消息队列  msgctl
7. 命令：
8. ipcs  -q ：查看消息队列
9. ipcrm  -q  msgid ：删除消息队列
11. int msgget(key_t key, int flag);
12.         功能：创建或打开一个消息队列
13.         参数：  key值
14.        flag：创建消息队列的权限IPC_CREAT|IPC_EXCL|0666
15.         返回值：成功：msgid
16.        失败：-1
17. int msgsnd(int msqid, const void *msgp, size_t size, int flag);
18.                 功能：添加消息
19.                 参数：msqid：消息队列的ID
20.       msgp：指向消息的指针。常用消息结构msgbuf如下：
21.           struct msgbuf{
22.             long mtype;        //消息类型
23.             char mtext[N]}；   //消息正文
24.    size：发送的消息正文的字节数
25.    flag：IPC_NOWAIT消息没有发送完成函数也会立即返回   
26.          0：直到发送完成函数才返回
27.                 返回值：成功：0
28.       失败：-1
29.                 使用：msgsnd(msgid, &msg,sizeof(msg)-sizeof(long), 0)
30.                 注意：消息结构除了第一个成员必须为long类型外，其他成员可以根据应用的需求自行定义。
31. int msgrcv(int msgid,  void* msgp,  size_t  size,  long msgtype,  int  flag);
32.         功能：读取消息
33.         参数：msgid：消息队列的ID
34.      msgp：存放读取消息的空间
35.      size：接受的消息正文的字节数
36.     msgtype：0：接收消息队列中第一个消息。
37.             大于0：接收消息队列中第一个类型为msgtyp的消息.
38.             小于0：接收消息队列中类型值不小于msgtyp的绝对值且类型值又最小的消息。
39.      flag：0：若无消息函数会一直阻塞
40.         IPC_NOWAIT：若没有消息，进程会立即返回ENOMSG
41.                 返回值：成功：接收到的消息的长度
42.       失败：-1
43. int msgctl ( int msgqid, int cmd, struct msqid_ds *buf );
44.                 功能：对消息队列的操作，删除消息队列
45.                 参数：msqid：消息队列的队列ID
46.      cmd：
47.         IPC_STAT：读取消息队列的属性，并将其保存在buf指向的缓冲区中。
48.         IPC_SET：设置消息队列的属性。这个值取自buf参数。
49.         IPC_RMID：从系统中删除消息队列。
50.      buf：消息队列缓冲区
51.         返回值：成功：0
52.       失败：-1
53.                 用法：msgctl（msgid, IPC_RMID, NULL）

复制代码

功能代码

基础实现

1. struct msgbuf{
2.     long type;
3.     int num;
4.     char buf[32];
5. };
6. int main(int argc, char const *argv[])
7. {
8.     key_t key;
9.     int msgid;
10.     //创建key值
11.     key = ftok("./app", 'b');
12.     if (key < 0)
13.     {
14.         perror("ftok err");
15.         return -1;
16.     }
17.     printf("%#x\n", key);
18.     //创建消息队列
19.     msgid = msgget(key, IPC_CREAT|IPC_EXCL|0666);
20.     if(msgid < 0)
21.     {
22.         if(errno == EEXIST)
23.             msgid = msgget(key, 0666);
24.         else
25.         {
26.             perror("msgget err");
27.             return -1;
28.         }     
29.     }
30.     //添加消息
31.     int size = sizeof(struct msgbuf)-sizeof(long);
32.     struct msgbuf msg = {1, 100, "hello"};
33.     struct msgbuf msg1 = {2, 200, "world"};
34.     msgsnd(msgid, &msg, size, 0);
35.     msgsnd(msgid, &msg1, size, 0);
36.     //读取消息
37.     struct msgbuf m;
38.     msgrcv(msgid, &m, size, 2, 0);
39.     printf("%d %s\n", m.num, m.buf);
40.     //删除消息队列
41.     msgctl(msgid, IPC_RMID, NULL);
42.     return 0;
43. }

复制代码

两个进程通过消息队列进行通信，一个进程从终端输入下发的指令，另一个进程接收指令，并打印对应操作语句。
如果输入LED ON，另一个进程输出 “开灯”
如果输入LED OFF，另一个进程输出 “关灯”

1. //send端
2. #include <stdio.h>
3. #include <stdio.h>
4. #include <sys/types.h>
5. #include <sys/ipc.h>
6. #include <errno.h>
7. #include <string.h>
8. #include <sys/msg.h>
11. struct msgbuf
12. {
13.     long type;
14.     char buf[32];
15. };
16. int main(int argc, char const *argv[])
17. {
18.     key_t key;
19.     int msgid;
20.     //创建key值
21.     key = ftok("./app", 'b');
22.     if (key < 0)
23.     {
24.         perror("ftok err");
25.         return -1;
26.     }
27.     printf("%#x\n", key);
28.     //创建消息队列
29.     msgid = msgget(key, IPC_CREAT|IPC_EXCL|0666);
30.     if(msgid < 0)
31.     {
32.         if(errno == EEXIST)
33.             msgid = msgget(key, 0666);
34.         else
35.         {
36.             perror("msgget err");
37.             return -1;
38.         }     
39.     }
40.     struct msgbuf msg;
41.     msg.type = 1;
42.     int s = sizeof(struct msgbuf)-sizeof(long);
43.     while(1)
44.     {
45.         scanf("%s", msg.buf);
46.         msgsnd(msgid, &msg, s, 0);
47.     }
48.     return 0;
49. }

复制代码

1. //recv端
2. #include <stdio.h>
3. #include <stdio.h>
4. #include <sys/types.h>
5. #include <sys/ipc.h>
6. #include <errno.h>
7. #include <string.h>
8. #include <sys/msg.h>
11. struct msgbuf
12. {
13.     long type;
14.     char buf[32];
15. };
16. int main(int argc, char const *argv[])
17. {
18.     key_t key;
19.     int msgid;
20.     //创建key值
21.     key = ftok("./app", 'b');
22.     if (key < 0)
23.     {
24.         perror("ftok err");
25.         return -1;
26.     }
27.     printf("%#x\n", key);
28.     //创建消息队列
29.     msgid = msgget(key, IPC_CREAT|IPC_EXCL|0666);
30.     if(msgid < 0)
31.     {
32.         if(errno == EEXIST)
33.             msgid = msgget(key, 0666);
34.         else
35.         {
36.             perror("msgget err");
37.             return -1;
38.         }     
39.     }
40.     struct msgbuf msg;
41.     int s = sizeof(struct msgbuf)-sizeof(long);
42.     while(1)
43.     {
44.         msgrcv(msgid, &msg, s, 1, 0);
45.         if(strcmp(msg.buf, "LEDON") == 0)
46.             printf("开灯\n");
47.         else if(strcmp(msg.buf, "LEDOFF") == 0)
48.             printf("关灯\n");
49.     }
50.    
51.     return 0;
52. }

复制代码

共享内存

函数接口

1. //步骤
2. 0）创建key值       
3. 1）创建或打开共享内存
4. 2）映射
5. 3）取消映射
6. 4）删除共享内存
8. key_t ftok(const char *pathname, int proj_id);
9. 功能：创建key值
10. 参数：pathname：文件名
11.      proj_id：取整型数的低8位数值
12. 返回值：成功：key值
13.        失败：-1
14. int shmget(key_t key, size_t size, int shmflg);
15. 功能：创建或打开共享内存
16. 参数：
17.     key  键值
18.     size   共享内存的大小
19.     shmflg   IPC_CREAT|IPC_EXCL|0777
20. 返回值：成功   shmid
21.       出错    -1
22. void  *shmat(int  shmid,const  void  *shmaddr,int  shmflg);
23. 功能：映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
24. 参数：
25.     shmid   共享内存的id号
26.     shmaddr   一般为NULL，表示由系统自动完成映射
27.               如果不为NULL，那么有用户指定
28.     shmflg：SHM_RDONLY就是对该共享内存只进行读操作
29.                 0     可读可写
30. 返回值：成功：完成映射后的地址，
31.       出错：-1的地址
32. 用法：if((p = (char *)shmat(shmid，NULL,0)) == (char *)-1)
33. int shmdt(const void *shmaddr);
34. 功能：取消映射
35. 参数：要取消的地址
36. 返回值：成功0  
37.       失败的-1
38. int  shmctl(int  shmid,int  cmd,struct  shmid_ds   *buf);
39. 功能：(删除共享内存)，对共享内存进行各种操作
40. 参数：
41.     shmid   共享内存的id号
42.     cmd     IPC_STAT 获得shmid属性信息，存放在第三参数
43.             IPC_SET 设置shmid属性信息，要设置的属性放在第三参数
44.             IPC_RMID:删除共享内存，此时第三个参数为NULL即可
45. 返回：成功0
46.      失败-1
47. 用法：shmctl(shmid,IPC_RMID,NULL);

复制代码

功能代码

基础

1. int main(int argc, char const *argv[])
2. {
3.     key_t key;
4.     int shmid;
5.     //创建key值
6.     key = ftok("./app", 'b');
7.     if (key < 0)
8.     {
9.         perror("ftok err");
10.         return -1;
11.     }
12.     printf("%#x\n", key);
13.     //创建或打印共享内存
14.     shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0666);
15.     if (shmid < 0)
16.     {
17.         if (errno == EEXIST)
18.             shmid = shmget(key, 128, 0666);
19.         else
20.         {
21.             perror("shmget err");
22.             return -1;
23.         }
24.     }
25.     printf("shmid:%d\n", shmid);
26.     //映射
27.     char *p = NULL;
28.     p = shmat(shmid, NULL, 0); //NULL:系统自动进行映射 0:可读可写
29.     if(p == (char *)-1)
30.     {
31.         perror("shmat err");
32.         return -1;
33.     }
34.     strcpy(p, "hello");
35.     printf("%s\n", p);
36.     //取消映射
37.     shmdt(p);
38.     //删除共享内存
39.     shmctl(shmid, IPC_RMID, NULL);
40.     return 0;
41. }

复制代码

练习：一个进程从终端输入，另一个进程将数据输出，借助共享内存通信。
要求：当输入quit时程序退出
同步：标志位

1. //read.c
2. #include <stdio.h>
3. #include <sys/types.h>
4. #include <sys/ipc.h>
5. #include <sys/shm.h>
6. #include <errno.h>
7. #include <string.h>
10. struct msg
11. {
12.     int flg;
13.     char buf[32];
14. };
15. int main(int argc, char const *argv[])
16. {
17.     key_t key;
18.     int shmid;
19.     //创建key值
20.     key = ftok("./app", 'b');
21.     if (key < 0)
22.     {
23.         perror("ftok err");
24.         return -1;
25.     }
26.     printf("%#x\n", key);
27.     //创建或打印共享内存
28.     shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0666);
29.     if (shmid < 0)
30.     {
31.         if (errno == EEXIST)
32.             shmid = shmget(key, 128, 0666);
33.         else
34.         {
35.             perror("shmget err");
36.             return -1;
37.         }
38.     }
39.     printf("shmid:%d\n", shmid);
40.     //映射
41.     struct msg *p = NULL;
42.     p = (struct msg *)shmat(shmid, NULL, 0); //NULL:系统自动进行映射 0:可读可写
43.     if(p == (struct msg *)-1)
44.     {
45.         perror("shmat err");
46.         return -1;
47.     }
48.     p->flg = 0;
49.     while(1)
50.     {
51.         scanf("%s", p->buf);
52.         p->flg = 1;
53.         if(strcmp(p->buf, "quit") == 0)
54.             break;
55.     }
58.     return 0;
59. }

复制代码

1. //write.c
2. #include <stdio.h>
3. #include <sys/types.h>
4. #include <sys/ipc.h>
5. #include <sys/shm.h>
6. #include <errno.h>
7. #include <string.h>
10. struct msg
11. {
12.     int flg;
13.     char buf[32];
14. };
15. int main(int argc, char const *argv[])
16. {
17.     key_t key;
18.     int shmid;
19.     //创建key值
20.     key = ftok("./app", 'b');
21.     if (key < 0)
22.     {
23.         perror("ftok err");
24.         return -1;
25.     }
26.     printf("%#x\n", key);
27.     //创建或打印共享内存
28.     shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0666);
29.     if (shmid < 0)
30.     {
31.         if (errno == EEXIST)
32.             shmid = shmget(key, 128, 0666);
33.         else
34.         {
35.             perror("shmget err");
36.             return -1;
37.         }
38.     }
39.     printf("shmid:%d\n", shmid);
40.     //映射
41.     struct msg *p = NULL;
42.     p = shmat(shmid, NULL, 0); //NULL:系统自动进行映射 0:可读可写
43.     if (p == (struct msg *)-1)
44.     {
45.         perror("shmat err");
46.         return -1;
47.     }
48.     p->flg = 0;
49.     while (1)
50.     {
51.         if (p->flg == 1)
52.         {
53.             if (strcmp(p->buf, "quit") == 0)
54.                 break;
55.             printf("data:%s\n", p->buf);
56.             p->flg = 0;
57.         }
58.     }
61.     //取消映射
62.     shmdt(p);
63.     //删除共享内存
64.     shmctl(shmid, IPC_RMID, NULL);
67.     return 0;
68. }

复制代码

信号灯集

函数接口

1. 步骤
2.         0）创建key值
3.         1）创建或打开信号灯集   semget
4.         2）初始化信号灯集  semctl
5.         3）pv操作  semop
6.         4）删除信号灯集  semctl
8. int semget(key_t key, int nsems, int semflg);
9. 功能：创建/打开信号灯
10. 参数：key：ftok产生的key值
11.     nsems：信号灯集中包含的信号灯数目
12.     semflg：信号灯集的访问权限，通常为IPC_CREAT |0666
13. 返回值：成功：信号灯集ID
14.        失败：-1
15. int semop ( int semid, struct sembuf  *opsptr,  size_t  nops);
16. 功能：对信号灯集合中的信号量进行PV操作
17. 参数：semid：信号灯集ID
18.      opsptr:操作方式
19.      nops:  要操作的信号灯的个数 1个
20. 返回值：成功 ：0
21.       失败：-1
22. struct sembuf {
23.    short  
24.        ; // 要操作的信号灯的编号
25.    short  sem_op;  //    0 :  等待，直到信号灯的值变成0
26.                    //   1  :  释放资源，V操作
27.                    //   -1 :  分配资源，P操作                    
28.     short  sem_flg; // 0（阻塞）,IPC_NOWAIT, SEM_UNDO
29. };
30. 用法：
31. 申请资源 P操作：
32.     mysembuf.sem_num = 0;
33.     mysembuf.sem_op = -1;
34.     mysembuf.sem_flg = 0;
35.     semop(semid, &mysembuf, 1);
36. 释放资源 V操作：
37.     mysembuf.sem_num = 0;
38.     mysembuf.sem_op = 1;
39.     mysembuf.sem_flg = 0;
40.     semop(semid, &mysembuf, 1);
41. int semctl ( int semid, int semnum,  int cmd…/*union semun arg*/);
42. 功能：信号灯集合的控制（初始化/删除）
43. 参数：semid：信号灯集ID
44.     semnum: 要操作的集合中的信号灯编号
45.      cmd：
46.         GETVAL：获取信号灯的值，返回值是获得值
47.         SETVAL：设置信号灯的值，需要用到第四个参数：共用体
48.         IPC_RMID：从系统中删除信号灯集合
49. 返回值：成功 0
50.       失败 -1
51. 用法：初始化：
52. union semun{
53.     int val; //信号灯的初值
54. }mysemun;
55. mysemun.val = 10;
56. semctl(semid, 0, SETVAL, mysemun);
57. 获取信号灯值：函数semctl(semid, 0, GETVAL)的返回值
58. 删除信号灯集：semctl(semid, 0, IPC_RMID);
61. ipcs -s:查看信号灯集
62. ipcrm -s  semid：删除信号灯集

复制代码

功能实现

1. union semun {
2.     int val; //信号灯的初值
3. };
4. int main(int argc, char const *argv[])
5. {
6.     key_t key;
7.     int semid;
8.     key = ftok("./app", 'b');
9.     if (key < 0)
10.     {
11.         perror("ftok err");
12.         return -1;
13.     }
14.     printf("%#x\n", key);
15.     //创建或打开信号灯集
16.     semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0666);
17.     if (semid < 0)
18.     {
19.         if (errno == EEXIST)
20.             semid = semget(key, 2, 0666);
21.         else
22.         {
23.             perror("semget err");
24.             return -1;
25.         }
26.     }
27.     else
28.     {
29.         //初始化
30.         union semun sem;
31.         sem.val = 10;
32.         semctl(semid, 0, SETVAL, sem); //对编号为0的信号灯初值设置为10
33.         sem.val = 0;
34.         semctl(semid, 1, SETVAL, sem); //对编号为1的信号灯初值设置为0
35.     }
36.     printf("semid:%d\n", semid);
37.     printf("%d\n",semctl(semid, 0, GETVAL));//获取编号为0的信号灯的值
38.     printf("%d\n",semctl(semid, 1, GETVAL));//获取编号为1的信号灯的值
40.     //pv操作
41.     //p操作:申请资源
42.     struct sembuf buf;
43.     buf.sem_num = 0; //信号灯的编号
44.     buf.sem_op = -1; //p操作
45.     buf.sem_flg = 0; //阻塞
46.     semop(semid, &buf, 1);
47.     //v操作:释放资源
48.     buf.sem_num = 1;
49.     buf.sem_op = 1; //v操作
50.     buf.sem_flg = 0;
51.     semop(semid, &buf, 1);
52.     printf("%d\n",semctl(semid, 0, GETVAL));//获取编号为0的信号灯的值
53.     printf("%d\n",semctl(semid, 1, GETVAL));//获取编号为1的信号灯的值
54.     //删除信号灯集
55.     semctl(semid, 0, IPC_RMID); //指定任意一个编号即可删除信号灯集
56.     return 0;
58.    

复制代码

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/ipc.h>
4. #include <sys/sem.h>
5. #include <errno.h>
8. union semun {
9.     int val; //信号灯的初值
10. };
11. //初始化
12. void seminit(int semid, int snum, int val)
13. {
14.     union semun sem;
15.     sem.val = val;
16.     semctl(semid, snum, SETVAL, sem);
17. }
18. //pv操作
19. void sem_op(int semid, int num, int op)
20. {
21.     struct sembuf buf;
22.     buf.sem_num = num;
23.     buf.sem_op = op;
24.     buf.sem_flg = 0;
25.     semop(semid, &buf, 1);
26. }
27. int main(int argc, char const *argv[])
28. {
29.     key_t key;
30.     int semid;
31.     key = ftok("./app", 'b');
32.     if (key < 0)
33.     {
34.         perror("ftok err");
35.         return -1;
36.     }
37.     printf("%#x\n", key);
38.     //创建或打开信号灯集
39.     semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0666);
40.     if (semid < 0)
41.     {
42.         if (errno == EEXIST)
43.             semid = semget(key, 2, 0666);
44.         else
45.         {
46.             perror("semget err");
47.             return -1;
48.         }
49.     }
50.     else
51.     {
52.         //初始化
53.         seminit(semid, 0, 10);
54.         seminit(semid, 1, 0);
55.     }
56.     printf("semid:%d\n", semid);
57.     printf("%d\n", semctl(semid, 0, GETVAL)); //获取编号为0的信号灯的值
58.     printf("%d\n", semctl(semid, 1, GETVAL)); //获取编号为1的信号灯的值
61.     //pv操作
62.     //p操作:申请资源
63.     sem_op(semid, 0, -1);
64.     //v操作:释放资源
65.     sem_op(semid, 1, 1);
68.     printf("%d\n", semctl(semid, 0, GETVAL)); //获取编号为0的信号灯的值
69.     printf("%d\n", semctl(semid, 1, GETVAL)); //获取编号为1的信号灯的值
72.     //删除信号灯集
73.     semctl(semid, 0, IPC_RMID);
76.     return 0;
77. }

复制代码

套接字

网络内容，笔者认为只写传输，脱离了我写这个目的（回顾，然后快速上手），所以放在了网络里面再写吧
其他补充

有名与无名管道的区别

无名管道有名管道特点只能在亲缘关系进程间使用半双工通信方式有固定的读端和写端，fd[0]：读，fd[1]:写端通过文件IO进行操作步骤：创建管道、读写操作不相关的任意进程间使用在路径中有管道文件，实际数据存在内核空间通过文件IO进行操作步骤：创建管道、打开管道、读写操作函数pipemkfifo读写特性当管道中没有数据，读阻塞当写满管道时，写阻塞当管道中没有数据，读阻塞当写满管道时，写阻塞IPC通讯的ftok函数

系统使用IPC通讯也就是消息队列，信号量，共享内存。这些操作都一个步骤就是使用这个函数接口ftok这个函数后面有2个参数const char *pathname, int proj_id第一个为我们创建的文件名，第二个为自己设置的ID值。

1. key = ftok("./app.c", 'a');
2.     if (key < 0)
3.     {
4.         perror("ftok err");
5.         return -1;
6.     }
7.   printf("%#x\n", key);
8. //打印结果为0x6130008e

复制代码

比如指定文件的索引节点号为65538，换算成16进制为0x010002，而你指定的ID值为38，换算成16进制为0x26，则最后的key_t返回值为0x26010002。

一个key值是由2部分确定，对应的key值才能通讯。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！