Linux进程间通信

0xlavon

在linux操作系统中，进程间通信（Inter-Process Communication, IPC）是进程之间传递数据或信号的机制。IPC在多进程编程中至关重要，适用于资源共享、数据同步、事件通知等场景。本文将介绍几种常见的Linux进程间通信方式，并给出相应的代码示例。

1. 管道（Pipes）

管道是一种最简单的进程间通信方式，主要用于父子进程之间的数据传输。

1.1 匿名管道（Unnamed Pipes）

匿名管道只能用于具有亲缘关系的进程之间，即父进程与子进程之间。

1.1.1 创建与使用

匿名管道通过`pipe()`系统调用创建：

1. 
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. 
   
6. int main() {
   
7.     int pipefd[2];
   
8.     char buffer[30];
   
9.     pid_t cpid;
   
10. 
    
11.     if (pipe(pipefd) == -1) {
    
12.         perror("pipe");
    
13.         exit(EXIT_FAILURE);
    
14.     }
    
15. 
    
16.     cpid = fork();
    
17.     if (cpid == -1) {
    
18.         perror("fork");
    
19.         exit(EXIT_FAILURE);
    
20.     }
    
21. 
    
22.     if (cpid == 0) {                /* 子进程 */
    
23.         close(pipefd[1]);          /* 关闭写端 */
    
24.         read(pipefd[0], buffer, sizeof(buffer));
    
25.         printf("子进程接收到的数据: %s\n", buffer);
    
26.         close(pipefd[0]);
    
27.     } else {                     /* 父进程 */
    
28.         close(pipefd[0]);          /* 关闭读端 */
    
29.         write(pipefd[1], "Hello, child process", 21);
    
30.         close(pipefd[1]);
    
31.     }
    
32. 
    
33.     return 0;
    
34. }
    

复制代码

1.2 命名管道（Named Pipes, FIFO）

命名管道可以用于任何两个进程之间的通信，具有路径名，与文件类似。

1.2.1 创建与使用

使用`mkfifo()`创建命名管道：

1. 
   
2. #include <fcntl.h>
   
3. #include <sys/stat.h>
   
4. #include <unistd.h>
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. 
   
8. int main() {
   
9.     char *fifo = "/tmp/my_fifo";
   
10.     char buffer[30];
    
11. 
    
12.     if (mkfifo(fifo, 0666) == -1) {
    
13.         perror("mkfifo");
    
14.         exit(EXIT_FAILURE);
    
15.     }
    
16. 
    
17.     pid_t cpid = fork();
    
18.     if (cpid == 0) {    /* 子进程 */
    
19.         int fd = open(fifo, O_RDONLY);
    
20.         read(fd, buffer, sizeof(buffer));
    
21.         printf("子进程接收到的数据: %s\n", buffer);
    
22.         close(fd);
    
23.     } else {            /* 父进程 */
    
24.         int fd = open(fifo, O_WRONLY);
    
25.         write(fd, "Hello, child process", 21);
    
26.         close(fd);
    
27.     }
    
28. 
    
29.     return 0;
    
30. }

复制代码

2. 消息队列（Message Queues）

消息队列允许进程以消息的形式进行通信，支持异步操作，且能够实现数据的结构化传输。

2.1 创建与使用

消息队列通过`msgget()`、`msgsnd()`、`msgrcv()`等系统调用进行操作：

1. 
   
2. 
   
3. #include <sys/types.h>
   
4. #include <sys/ipc.h>
   
5. #include <sys/msg.h>
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. #include <string.h>
   
9. 
   
10. struct msg_buffer {
    
11.     long msg_type;
    
12.     char msg_text[100];
    
13. };
    
14. 
    
15. int main() {
    
16.     key_t key;
    
17.     int msgid;
    
18.     struct msg_buffer message;
    
19. 
    
20.     key = ftok("progfile", 65);
    
21.     msgid = msgget(key, 0666 | IPC_CREAT);
    
22.     message.msg_type = 1;
    
23. 
    
24.     strcpy(message.msg_text, "Hello, message queue");
    
25.     msgsnd(msgid, &message, sizeof(message), 0);
    
26. 
    
27.     msgrcv(msgid, &message, sizeof(message), 1, 0);
    
28.     printf("接收到的消息: %s\n", message.msg_text);
    
29. 
    
30.     msgctl(msgid, IPC_RMID, NULL);
    
31. 
    
32.     return 0;
    
33. }
    

复制代码

3. 共享内存（Shared Memory）

共享内存是最快的IPC方式，允许多个进程直接访问同一块内存区域。

3.1 创建与使用

共享内存通过`shmget()`、`shmat()`、`shmdt()`等系统调用进行操作：

1. 
   
2. 
   
3. #include <sys/ipc.h>
   
4. #include <sys/shm.h>
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <string.h>
   
8. 
   
9. int main() {
   
10.     key_t key = ftok("shmfile", 65);
    
11.     int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    
12.     char *str = (char*) shmat(shmid, (void*)0, 0);
    
13. 
    
14.     strcpy(str, "Hello, shared memory");
    
15.     printf("写入数据: %s\n", str);
    
16. 
    
17.     shmdt(str);
    
18.     shmctl(shmid, IPC_RMID, NULL);
    
19. 
    
20.     return 0;
    
21. }

复制代码

4. 信号量（Semaphores）

信号量主要用于进程同步，但也可以用于进程间通信。

4.1 创建与使用

信号量通过`semget()`、`semop()`、`semctl()`等系统调用进行操作：

1. 
   
2. #include <sys/ipc.h>
   
3. #include <sys/sem.h>
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. 
   
7. union semun {
   
8.     int val;
   
9.     struct semid_ds *buf;
   
10.     unsigned short  *array;
    
11. };
    
12. 
    
13. int main() {
    
14.     key_t key = ftok("semfile", 65);
    
15.     int semid = semget(key, 1, 0666 | IPC_CREAT);
    
16.     union semun u;
    
17.     u.val = 1;
    
18.     semctl(semid, 0, SETVAL, u);
    
19. 
    
20.     struct sembuf sb = {0, -1, 0};  // P操作
    
21.     semop(semid, &sb, 1);
    
22. 
    
23.     printf("进入临界区\n");
    
24.     sleep(2);  // 模拟临界区操作
    
25.     printf("退出临界区\n");
    
26. 
    
27.     sb.sem_op = 1;  // V操作
    
28.     semop(semid, &sb, 1);
    
29. 
    
30.     semctl(semid, 0, IPC_RMID);
    
31. 
    
32.     return 0;
    
33. }
    

复制代码

5. 套接字（Sockets）

套接字不仅用于网络通信，也可以用于本地进程间通信（Unix Domain Sockets）。

5.1 创建与使用

本地套接字通过`socket()`、`bind()`、`listen()`、`accept()`等系统调用进行操作：

1. 
   
2. #include <sys/socket.h>
   
3. #include <sys/un.h>
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <unistd.h>
   
7. 
   
8. #define SOCKET_PATH "/tmp/socket"
   
9. 
   
10. int main() {
    
11.     int server_fd, client_fd;
    
12.     struct sockaddr_un addr;
    
13.     char buffer[100];
    
14.     server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    
15. 
    
16.     memset(&addr, 0, sizeof(struct sockaddr_un));
    
17.     addr.sun_family = AF_UNIX;
    
18.     strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);
    
19.     bind(server_fd, (struct sockaddr*)&addr, sizeof(struct sockaddr_un));
    
20.     listen(server_fd, 5);
    
21. 
    
22.     client_fd = accept(server_fd, NULL, NULL);
    
23.     read(client_fd, buffer, sizeof(buffer));
    
24.     printf("接收到的数据: %s\n", buffer);
    
25. 
    
26.     close(client_fd);
    
27.     close(server_fd);
    
28.     unlink(SOCKET_PATH);
    
29. 
    
30.     return 0;
    
31. }

复制代码

6. 总结

Linux提供了多种进程间通信方式，每种方式都有其适用的场景和优缺点：

(1) 管道（匿名管道和命名管道）简单易用，适用于父子进程或相关进程之间的通信。

(2) 消息队列适用于需要结构化数据传输且通信双方相对独立的场景。

(3) 共享内存是最快的通信方式，但需要进程间同步机制确保数据一致性。

(4) 信号量主要用于进程同步，也可以结合其他IPC方式使用。

(5) 套接字适用于本地和网络通信，具有很强的灵活性和扩展性。

选择合适的IPC方式，能够有效提高系统的性能和稳定性。希望本文能帮助读者更好地理解和应用Linux进程间通信技术。Happy coding with Linux IPC!