Linux系统编程——进程间通信的学习
学习参考博文：
- 进程间的五种通信方式介绍
- Linux 信号介绍
Linux系统编程学习相关博文
- Linux系统编程——文件编程的学习
- Linux系统编程——进程的学习
- Linux系统编程——线程的学习
- Linux系统编程——网络编程的学习
Linux系统编程——进程间通信的学习
- 一、概述
-
- 1. 无名管道和有名管道的区别
- 2. 当打开一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：
- 3. 消息队列
- 4. 共享内存
- 5. 信号
- 6. 信号量
- 二、进程间通信API
- 三、API介绍
-
- 1. pipe函数
- 2. mkfifo函数
- 3. msgget函数
- 4. msgsnd函数
- 5. msgrcv函数
- 6. msgctl函数
- 7. shmget函数
- 8. shmat函数
- 9. shmdt函数
- 10. shmctl函数
- 11. signal函数
- 12. kill函数
- 13. sigaction函数
- 14. sigqueue函数
- 15. semget函数
- 16. semctl函数
- 17. semop函数
- 四、API的使用例子
-
- 1. pipe函数
- 2. mkfifo函数
- 3. msgget、msgsnd、msgrcv、msgctl函数
- 4. shmget、shmat、shmdt、shmctl函数
- 5. signal函数
- 6. kill函数
- 7. sigaction函数
- 8. sigqueue函数
- 9. semget、semctl、semop函数
一、概述
常规学习Linux系统编程的内容是复杂且繁多的，不推荐刚开始接触代码的朋友去学习，所以介绍Linux系统编程的目的主要是以应用开发为主。
进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。
IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。
1. 无名管道和有名管道的区别
- 无名管道是半双工的(即数据只能在一个方向上流动)，具有固定的读端和写端。它只能用于具有亲缘关系的进程之间的通信(也是父子进程或者兄弟进程之间)，它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
- 有名管道可以在无关的进程之间交换数据，与无名管道不同。有名管道可以在无关的进程之间交换数据，与无名管道不同。
2. 当打开一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：
-
若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
-
若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。
3. 消息队列
- 消息队列，是消息的链接表，存放在内核中。
- 消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
4. 共享内存
- 共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
- 因为多个进程可以同时操作，所以需要进行同步。
- 信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
5. 信号
- 每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。
- 信号定义在signal.h头文件中，信号名都定义为正整数。
- 具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用。
- 信号的处理有三种方法，分别是：忽略、捕捉和默认动作
6. 信号量
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
- 信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
- 信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
- 每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。(P操作相当于拿钥匙，V操作相当于放钥匙)
- 支持信号量组。
二、进程间通信API
在Linux系统中，操作系统提供了一系列的API，详细看下图
1. 管道
创建无名管道 pipe()
创建有名管道 mkfifo()
2. 消息队列
创建或打开消息队列 msgget()
添加消息 msgsnd()
读取消息 msgrcv()
控制消息队列 msgctl()
3. 共享内存
创建或获取共享内存 shmget()
将共享内存映射到当前进程的虚拟地址空间 shmat()
断开与共享内存的连接 shmdt()
控制共享内存的相关信息 shmctl()
4. 信号
信号处理函数 入门版 signal() / 高级版 sigaction()
信号发送函数 入门版 kill() / 高级版 sigqueue()
5. 信号量
创建或获取信号量组 semget()
控制信号量的相关信息 semctl()
对信号量组进行操作 semop()
三、API介绍
1. pipe函数
#include 2. mkfifo函数
#include 3. msgget函数
#include 4. msgsnd函数
#include 5. msgrcv函数
#include 6. msgctl函数
#include 7. shmget函数
#include 8. shmat函数
#include 9. shmdt函数
#include 10. shmctl函数
#include 11. signal函数
#include 12. kill函数
#include 13. sigaction函数
#include 14. sigqueue函数
#include 15. semget函数
#include 16. semctl函数
#include 17. semop函数
#include 四、API的使用例子
1. pipe函数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <unistd.h>
6
7 int main()
8 {
9 // int pipe(int pipefd[2]);
10
11 int pid = 0;
12 int fd[2] = {0};
13 char buf[128] = {0} ;
14
15 if(pipe(fd) == -1){ //创建管道
16 printf("create pipe failed\n");
17 perror("why");
18 }
19
20 pid = fork(); //创建子进程
21
22 if(pid < 0){
23 printf("create child failed\n");
24 perror("why");
25 }
26 else if(pid > 0){ //父进程
27 sleep(1);
28
29 printf("This is father\n");
30 close(fd[0]); //关闭读端
31 write(fd[1], "Hello World", strlen("Hello World")); //写入数据
32
33 wait(NULL);
34 }
35 else{ //子进程
36 printf("This is child\n");
37 close(fd[1]); //关闭写端
38 read(fd[0], buf, sizeof(buf)); //读取数据
39 printf("read data: %s\n", buf);
40
41 exit(0);
42 }
43
44 return 0;
45 }
2. mkfifo函数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #include <errno.h>
8 #include <fcntl.h>
9
10 int main()
11 {
12 // int mkfifo(const char *pathname, mode_t mode);
13 int fd = 0;
14
15 if((mkfifo("./file", 0600) == -1) && errno != EEXIST){ //创建管道
16 printf("create failed\n");
17 perror("why");
18 }
19
20 fd = open("./file", O_RDONLY);
21
22 return 0;
23 }
3. msgget、msgsnd、msgrcv、msgctl函数
接收端demo
1 #include <stdio.h>
2 #include <errno.h>
3 #include <string.h>
4 #include <stdlib.h>
5
6 #include <sys/types.h>
7 #include <sys/ipc.h>
8 #include <sys/msg.h>
9
10 // 1. int msgget(key_t key, int msgflg);
11 // 2. int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
12 // 3. ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
13
14 struct msgbuf {
15 long mtype; /* message type, must be > 0 */
16 char mtext[128]; /* message data */
17 }
18
19 int main()
20 {
21 int msgId;
22
23 key_t key;
24
25 struct msgbuf readBuf;
26 struct msgbuf sendBuf = {988, "Welcome your coming"};
27
28 key = ftok(".", 23); //获取key
29 printf("key = 0x%x\n", key);
30
31 msgId = msgget(key, IPC_CREAT|0777); //创建消息队列
32
33 if(msgId == -1){
34 printf("creat quene failed\n");
35 perror("why");
36 }
37
38 msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 888, 0); //读取消息
39 printf("get message from quene, content: %s\n", readBuf.mtext);
40
41 msgsnd(msgId, &sendBuf, sizeof(sendBuf.mtext), 0); //发送消息
42
43 msgctl(msgId, IPC_RMID, NULL); //删除消息队列
44
45 return 0;
46 }
发送端
1 #include <stdio.h>
2 #include <errno.h>
3 #include <string.h>
4 #include <stdlib.h>
5
6 #include <sys/types.h>
7 #include <sys/ipc.h>
8 #include <sys/msg.h>
9
10 // 1. int msgget(key_t key, int msgflg);
11 // 2. int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
12 // 3. ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
13
14 struct msgbuf {
15 long mtype; /* message type, must be > 0 */
16 char mtext[128]; /* message data */
17 };
18
19 int main()
20 {
21 int msgId;
22
23 key_t key;
24
25 struct msgbuf readBuf;
26 struct msgbuf sendBuf = {888, "This is content from quene"};
27
28 key = ftok(".", 23); //获取key
29 printf("key = 0x%x\n", key);
30
31 msgId = msgget(key, IPC_CREAT|0777); //创建消息队列
32
33 if(msgId == -1){
34 printf("creat quene failed\n");
35 perror("why");
36 }
37
38 msgsnd(msgId, &sendBuf, sizeof(sendBuf.mtext), 0); //发送消息
39 printf("Send over!\n");
40
41 msgrcv(msgId, &readBuf, sizeof(readBuf.mtext), 988, 0); //读取消息
42 printf("get message from msgGet, content: %s\n", readBuf.mtext);
43
44 msgctl(msgId, IPC_RMID, NULL);
45
46 return 0;
47 }
4. shmget、shmat、shmdt、shmctl函数
接收端
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <sys/ipc.h>
6 #include <sys/shm.h>
7 #include <sys/types.h>
8
9 // 1. int shmget(key_t key, size_t size, int shmflg);
10 // 2. void *shmat(int shmid, const void *shmaddr, int shmflg);
11 // 3. int shmdt(const void *shmaddr);
12 // 4. int shmctl(int shmid, int cmd, struct shmid_ds *buf);
13
14 int main()
15 {
16 int shmid;
17 char *shmaddr;
18
19 key_t key;
20
21 key = ftok(".", 1); //获取key
22
23 shmid = shmget(key, 1024*4, 0); //获取共享内存
24
25 shmaddr = shmat(shmid, NULL, 0); //映射
26
27 printf("read: %s\n", shmaddr);
28
29 shmdt(shmaddr); //断开共享内存
30
31 printf("quit\n");
32
33 return 0;
34 }
发送端
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <sys/ipc.h>
6 #include <sys/shm.h>
7 #include <sys/types.h>
8
9 // 1. int shmget(key_t key, size_t size, int shmflg);
10 // 2. void *shmat(int shmid, const void *shmaddr, int shmflg);
11 // 3. int shmdt(const void *shmaddr);
12 // 4. int shmctl(int shmid, int cmd, struct shmid_ds *buf);
13
14 int main()
15 {
16 int shmid;
17 char *shmaddr;
18
19 key_t key;
20
21 key = ftok(".", 1); //获取key
22
23 shmid = shmget(key, 1024*4, IPC_CREAT|0666); //创建共享内存
24
25 if(shmid == -1){
26 perror("create shm failed");
27 exit(-1);
28 }
29
30 shmaddr = shmat(shmid, NULL, 0); //映射
31
32 strcpy(shmaddr, "Hello World"); //写入数据
33 printf("write..\n");
34 sleep(5);
35
36 shmdt(shmaddr); //断开共享内存
37
38 shmctl(shmid, IPC_RMID, NULL); //删除共享内存
39
40 printf("quit\n");
41
42 return 0;
43 }
5. signal函数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <signal.h>
6
7 // typedef void (*sighandler_t)(int);
8 // 1. sighandler_t signal(int signum, sighandler_t handler);
9
10 void handler(int signum) //处理函数
11 {
12 switch(signum){
13 case 2:
14 printf("signum = %d\n", signum);
15 printf("never quit\n");
16
17 break;
18 case 9:
19 printf("signum = %d\n", signum);
20 printf("never quit\n");
21
22 break;
23 case 10:
24 printf("signum = %d\n", signum);
25 printf("never quit\n");
26
27 break;
28 default:
29 printf("signum = %d\n", signum);
30 printf("never quit\n");
31
32 break;
33 }
34 }
35
36 int main()
37 {
38 signal(SIGHUP, handler); //捕获SIGHUP信号
39 signal(SIGINT, handler); //捕获SIGINT信号
40 signal(SIGKILL, handler); //捕获SIGKILL信号
41 signal(SIGUSR1, handler); //捕获SIGUSR1信号
42
43 while(1);
44
45 return 0;
46 }
6. kill函数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <signal.h>
6 #include <sys/types.h>
7
8 // typedef void (*sighandler_t)(int);
9 // 1. sighandler_t signal(int signum, sighandler_t handler);
10 // 2. int kill(pid_t pid, int sig);
11
12 int main(int argc, char **argv)
13 {
14 int pid;
15 int signum;
16 char cmd[32] = "/0";
17
18 if(argc < 3){
19 printf("please input three param\n");
20 exit(-1);
21 }
22
23 signum = atoi(argv[1]); //将字符串转换成整型数(第二个参数)
24 pid = atoi(argv[2]); //将字符串转换成整型数(第三个参数)
25
26 sprintf(cmd, "kill -%d %d", signum, pid);
27 //kill(pid, signum); //发送指令
28
29 system(cmd); //发送指令
30
31 return 0;
32 }
7. sigaction函数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <sys/types.h>
6 #include <unistd.h>
7 #include <signal.h>
8
9 // 1. int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
10
11 void handler(int signum, siginfo_t *info, void *context) //处理函数
12 {
13 printf("\nsignum = %d\n", signum);
14
15 if(context != NULL){
16 printf("get data: %d\n", info->si_int);
17 printf("get data: %d\n", info->si_value.sival_int);
18 printf("from: %d\n",info->si_pid);
19 }
20 }
21
22 int main()
23 {
24 struct sigaction act;
25
26 printf("pid = %d\n", getpid());
27
28 act.sa_sigaction = handler;
29 act.sa_flags = SA_SIGINFO; //如果在sa_flags中指定了SA SIGINFO，则sa _sigaction(而不是sa_handler)指定signum的信号处理函数。
30
31 sigaction(SIGUSR1, &act, NULL); 捕获SIGUSR1信号
32
33 while(1);
34
35 return 0;
36 }
8. sigqueue函数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <sys/types.h>
6 #include <unistd.h>
7 #include <signal.h>
8
9 // 1. int sigqueue(pid_t pid, int sig, const union sigval value);
10
11 int main(int argc, char **argv)
12 {
13 int pid;
14 int signum;
15
16 pid = atoi(argv[2]); //将字符串转换成整型数(第三个参数)
17 signum = atoi(argv[1]); //将字符串转换成整型数(第二个参数)
18
19 union sigval value;
20 value.sival_int = 100; //发送的整形数据
21
22 sigqueue(pid, signum, value); //发送函数
23
24 printf("pid = %d\n", getpid()); //打印pid号
25
26 return 0;
27 }
9. semget、semctl、semop函数
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4
5 #include <sys/types.h>
6 #include <sys/ipc.h>
7 #include <sys/sem.h>
8 #include <unistd.h>
9
10 // 1. int semget(key_t key, int nsems, int semflg);
11 // 2. int semctl(int semid, int semnum, int cmd, ...);
12 // 3. int semop(int semid, struct sembuf *sops, unsigned nsops);
13
14 union semun {
15 int val; /* Value for SETVAL */
16 struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
17 unsigned short *array; /* Array for GETALL, SETALL */
18 struct seminfo *__buf; /* Buffer for IPC_INFO
19 (Linux-specific) */
20 };
21
22 void pGetKey(int semid) //拿钥匙
23 {
24 struct sembuf sop;
25
26 sop.sem_num = 0; /* Operate on semaphore 0 */
27 sop.sem_op = -1; /* Wait for value to equal 0 */
28 sop.sem_flg = SEM_UNDO;
29
30 semop(semid, &sop, 1); //操作信号量
31
32 printf("Get key\n");
33 }
34
35 void vPutBackKey(int semid) //放钥匙
36 {
37 struct sembuf sop;
38
39 sop.sem_num = 0; /* Operate on semaphore 0 */
40 sop.sem_op = 1; /* Wait for value to equal 0 */
41 sop.sem_flg = SEM_UNDO;
42
43 semop(semid, &sop, 1); //操作信号量
44
45 printf("Put back key\n");
46 }
47
48 int main()
49 {
50 int pid;
51 int semid;
52 key_t key;
53
54 union semun value;
55
56 key = ftok(".", 23); //获取key
57
58 //创建/获取一个信号量
59 semid = semget(key, 1, IPC_CREAT|0666); //创建信号量集
60
61 value.val = 0; //初始时盒子里没钥匙
62
63 //控制信号量集
64 semctl(semid, 0, SETVAL, value); //信号量集初始化
65
66 pid = fork(); //创建子进程
67
68 if(pid > 0){ //父进程
69 // 拿钥匙——如果盒子里没钥匙，父进程出于阻塞状态
70 pGetKey(semid); //拿钥匙
71 printf("This is father\n");
72 // 放钥匙
73 vPutBackKey(semid); //放钥匙
74 }
75 else if(pid == 0){ //子进程
76 printf("This is child\n");
77 // 放钥匙——因初始化时盒子里没钥匙，无论是不是父进程先运行它都会处于阻塞状态，等子进程把放入钥匙后父进程才能拿钥匙开门
78 vPutBackKey(semid); //放钥匙
79 }
80 else{
81 printf("fork error\n");
82 }
83
84 return 0;
85 }