当前位置：首页 > news >正文

论Linux进程间通信

news 2025/3/16 18:09:19

目的

为什么能通信

进程间通信的框架

进程间通信机制的类型

⑴共享内存式

⑵消息传递式

进程间通信机制的接口设计

进程间通信机制

管道通信：最原始的 “传声筒”

信号（Signals）

文件（Files）

信号量：共享资源的 “交通警察”

共享内存：进程间的 “共享空间”

消息队列：进程间的 “邮局”

套接字：跨网络的 “通信使者”

应用场景

数据传输与共享

资源共享与同步

通知与事件传递

任务协作与并行处理

构建复杂应用架构

目的

数据传输：⼀个进程需要将它的数据发送给另⼀个进程
资源共享：多个进程之间共享同样的资源。
通知事件：⼀个进程需要向另⼀个或⼀组进程发送消息，通知它（它们）发⽣了某种事件（如进程终⽌时要通知⽗进程）。
进程控制：有些进程希望完全控制另⼀个进程的执⾏（如Debug进程），此时控制进程希望能够
拦截另⼀个进程的所有陷⼊和异常，并能够及时知道它的状态改变。

为什么能通信

在操作系统中，内核空间是所有进程共用的，而每个进程都拥有自己的用户空间。这种结构类似于一个公共图书馆，每个进程都有自己的阅读室”（用户空间），但它们都可以通过特定的走廊”（系统调用）访问这个图书馆（内核空间）。

进程之间能够通信，正是因为它们可以通过这个共享的内核空间进行交互。尽管每个进程的用户空间是相互独立的，但它们与内核空间之间并不是完全隔离的，而是通过系统调用这个走廊”进行沟通。

在Linux系统中，采用了两级保护机制，其中0级为内核使用，3级为用户程序使用。每个进程都拥有自己的私有用户空间（0～3G），这个空间对其他进程是不可见的。而最高的1GB字节虚拟内核空间为所有进程和内核所共享。

内核空间中存储的是内核代码和数据，而用户空间中存储的是用户程序的代码和数据。无论是内核空间还是用户空间，它们都处于虚拟空间中。尽管内核空间在每个虚拟空间中都占据了最高的1GB字节，但映射到物理内存时，总是从最低地址（0x00000000）开始。

通过一幅图来解释进程间通信的原理，可以看到，尽管进程之间有空间隔离，但它们都与内核相连，可以通过特殊的系统调用与内核进行沟通，从而实现与其他进程的通信。这就像不同的房间虽然相互独立，但都通过管道与一个中央控制室相连。

在这个比喻中，进程就是各个房间，而内核就是中央控制室。进程虽然不能直接访问其他进程的用户空间，但可以通过系统调用与内核进行交互，内核再将信息传递给其他进程，从而实现进程间通信。

例如，当一个进程需要向另一个进程发送数据时，它可以通过系统调用将数据写入内核空间的特定区域，内核再通知目标进程从该区域读取数据。

进程间通信的框架

进程间通信机制由存在于内核空间的通信中枢和存在于用户空间的通信接口组成，两者关系紧密。通信中枢就如同邮局或基站，为通信提供核心机制；通信接口则像信纸或手机，为用户提供使用通信机制的方法。

为了更直观地理解进程间通信机制的结构，我们可以通过以下图示来展示：

用户通过通信接口让通信中枢建立通信信道或传递通信信息。例如，在使用共享内存进行进程间通信时，用户通过特定的系统调用接口（通信接口）请求内核空间的通信中枢为其分配一块共享内存区域，并建立起不同进程对该区域的访问路径。

进程间通信机制的类型

⑴共享内存式

通信中枢建立好通信信道后，通信双方之后的通信不需要通信中枢的协助。这就如同两个房间之间打开了一扇门，双方可以直接通过这扇门进行交流，而不需要中间人的帮忙。

但是，由于通信信息的传递不需要通信中枢的协助，通信双方需要进程间同步，以保证数据读写的一致性。否则，就可能出现数据踩踏或者读到垃圾数据的情况。比如，多个进程同时对共享内存进行读写操作时，需要通过信号量等机制来确保在同一时间只有一个进程能够进行写操作，避免数据冲突。

⑵消息传递式

通信中枢建立好通信信道后，每次通信还都需要通信中枢的协助。这种方式就像一个中间人在两个房间之间传递信息，每次传递都需要经过中间人。

消息传递式又分为有边界消息和无边界消息。无边界消息是字节流，发过来是一个一个的字节，要靠进程自己设计如何区分消息的边界。有边界消息的发送和接收都是以消息为基本单位，类似于一封封完整的信件，接收方可以明确地知道每个消息的开始和结束位置。

进程间通信机制的接口设计

按照通信双方的关系，可分为对称型通信和非对称型通信：

消息传递式进程间通信一般用于非对称型通信，例如在客户服务关系中，客户端向服务端发送请求消息，服务端接收消息并进行处理后返回响应消息，整个通信过程通过通信中枢进行消息的传递。
共享内存式进程间通信一般用于对称型通信，也可用于非对称型通信。在对称型通信中，通信双方关系对等，如同两个平等的伙伴共同使用一块共享内存进行数据交换。在非对称型通信中，也可以通过共享内存实现一方写入数据，另一方读取数据的模式。

进程间通信机制一般要实现三类接口：

如何建立通信信道，谁去建立通信信道。对于对称型通信来说，谁去建立通信信道无所谓，有一个人去建立就可以了，后者直接加入通信信道。对于非对称型通信，一般是由服务端、消费者建立通信信道，客户端、生产者则加入这个通信信道。不同的进程间通信机制，有不同的接口来创建信道。例如，在使用共享内存时，可以通过特定的系统调用（如 shmget）来创建共享内存区域，建立通信信道。

后者如何找到并加入这个通信信道。一般情况是，双方通过提前约定好的信道名称找到信道句柄，通过信道句柄加入通信信道。但是有的是通过继承把信道句柄传递给对方，有的是通过其它进程间通信机制传递信道句柄，有的则是通过信道名称直接找到信道，不需要信道句柄。

如何使用通信信道。一旦通信信道建立并加入成功，进程就需要知道如何正确地使用通信信道进行数据的读写操作。例如，在使用管道进行通信时，进程需要明确知道哪个文件描述符是用于读，哪个是用于写，以及在读写过程中的各种规则和特殊情况的处理。

进程间通信机制

管道通信：最原始的 “传声筒”

⑴匿名管道：匿名管道通常用于临时的、简单的数据传输，仅用于有亲缘关系的进程。当使用 fork 函数创建子进程时，子进程会继承父进程的文件描述符表。父进程通过 pipe 函数自动以读写的方式打开同一个管道文件，并将文件描述符返回给一个数组。其中，数组的一个元素存储以读的方式打开管道文件所返回的文件描述符，另一个元素存储以写的方式打开管道文件所返回的文件描述符。

站在文件描述符角度深度理解管道，子进程拷贝父进程后，就不需要再以读或者写的方式打开管道文件了。确保管道通信的单向性，父子进程要分别关闭读端和写端。例如，如果希望数据从父进程流向子进程，就关闭父进程的读端，子进程的写端；如果希望数据从子进程流向父进程，就关闭父进程的写端，子进程的读端。

#include<iostream>
#include<cassert>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<cstdlib>using namespace std;#define MAX 1024int main()
{int pipefd[2]={0};int n=pipe(pipefd);assert(n==0);cout<<"pipefd[0]:"<<pipefd[0]<<" pipefd[1]:"<<pipefd[1]<<endl;//创建子进程pid_t pid=fork();//判断创建是否失败if(pid<0){perror("fork");exit(1);}//子进程else if(pid==0){//关闭读端close(pipefd[0]);int cnt = 10;while(cnt){char message[MAX];snprintf(message,sizeof(message),"I am child process, message %d\n",cnt);write(pipefd[1],message,strlen(message));cnt--;sleep(1);}exit(0);}//父进程close(pipefd[1]);//关闭写端char buffer[MAX];while(true){sleep(1);//从文件描述符对应的管道里面读取数据size_t n=read(pipefd[0],buffer,sizeof(buffer)-1);if(n>0){buffer[n]=0;std::cout << getpid() << " -> " << "child sends: " << buffer << " to me" << std::endl;}else if(n==0){std::cout << "father return val(n):" << n << std::endl;std::cout << "child quit, me too!!!" << std::endl;sleep(1);break;}}std::cout << "finish reading..." << std::endl;// 写端已经退出，读完后关闭读端close(pipefd[0]);pid_t rid = waitpid(pid, nullptr, 0);if (rid == pid) {std::cout << "wait success" << std::endl;}return 0;
}

⑵有名管道FIFO：有名管道允许不相关的进程通过文件系统中的一个路径名进行通信。创建有名管道可以使用 mkfifo 函数，判断有名管道是否已存在，若尚未创建，则以相应的权限创建。以下是创建有名管道和使用有名管道进行通信的代码示例：

发送端：

#include"name_fifo.hpp"
#include<unistd.h>
#include<stdlib.h>
#include<fcntl.h>
#include<limits.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h>
#include<string.h>
#include<errno.h>#define MYFIFO   "/tmp/myfifo"/* 有名管道文件名*/
#define MAX_BUFFER_SIZE   PIPE_BUF/*常量PIPE_BUF 定义在于limits.h中*/int main() {char buff[MAX_BUFFER_SIZE];int  fd;int  nread;/* 判断有名管道是否已存在，若尚未创建，则以相应的权限创建*/if (access(MYFIFO, F_OK) == -1) {if ((mkfifo(MYFIFO, 0666) < 0) && (errno!= EEXIST)) {printf("Cannot create fifo file\n");exit(1);}/* 以只读阻塞方式打开有名管道 */fd = open(MYFIFO, O_RDONLY);if (fd == -1) {printf("Open fifo file error\n");exit(1);}while (1) {memset(buff, 0, sizeof(buff));if ((nread = read(fd, buff, MAX_BUFFER_SIZE)) > 0) {printf("Read '%s' from FIFO\n", buff);}close(fd);exit(0);}}
}

接收端：

#include"name_fifo.hpp"
#include<unistd.h>
#include<stdlib.h>
#include<fcntl.h>
#include<limits.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h>
#include<string.h>
#include<errno.h>#define MYFIFO   "/tmp/myfifo"/* 有名管道文件名*/
#define MAX_BUFFER_SIZE   PIPE_BUF/*常量PIPE_BUF 定义在于limits.h中*/int main() {char buff[MAX_BUFFER_SIZE];int  fd;int  nread;/* 判断有名管道是否已存在，若尚未创建，则以相应的权限创建*/if (access(MYFIFO, F_OK) == -1) {if ((mkfifo(MYFIFO, 0666) < 0) && (errno!= EEXIST)) {printf("Cannot create fifo file\n");exit(1);}/* 以只读阻塞方式打开有名管道 */fd = open(MYFIFO, O_RDONLY);if (fd == -1) {printf("Open fifo file error\n");exit(1);}while (1) {memset(buff, 0, sizeof(buff));if ((nread = read(fd, buff, MAX_BUFFER_SIZE)) > 0) {printf("Read '%s' from FIFO\n", buff);}close(fd);exit(0);}}
}

信号（Signals）

信号是一种软件中断，是操作系统用来通知进程某个事件已经发生的一种方式。可以使用 signal 函数注册信号处理函数。以下是注册信号处理函数的代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>// 信号处理函数
void sighandler(int signo) {printf("signo==[%d]\n", signo);
}int main() {// 注册信号处理函数signal(SIGINT, sighandler);while (1) {sleep(10);}return 0;
}

文件（Files）

文件是一种持久化存储机制，可用于进程间通信。写进程将数据写入文件，读进程从文件中读取数据。以下是写进程和读进程的代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main() {// 写进程FILE *fp = fopen("data.txt", "w");if (fp == NULL) {perror("Error opening file for writing");return 1;}char *data = "Hello from write process!";fputs(data, fp);fclose(fp);// 读进程fp = fopen("data.txt", "r");if (fp == NULL) {perror("Error opening file for reading");return 1;}char buffer[100];fgets(buffer, sizeof(buffer), fp);printf("Read from file: %s\n", buffer);fclose(fp);return 0;
}

信号量：共享资源的 “交通警察”

信号量是一种计数器，用于控制对共享资源的访问。可以使用信号量控制对共享内存的访问。以下是使用信号量控制对共享内存访问的代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>union semun {int val;struct semid_ds *buf;unsigned short *arry;
};int set_semvalue(int sem_id) {union semun sem_union;sem_union.val = 1;if (semctl(sem_id, 0, SETVAL, sem_union) == -1)return 0;return 1;
}void del_semvalue(int sem_id) {union semun sem_union;if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1)fprintf(stderr, "Failed to delete semaphore\n");
}int semaphore_p(int sem_id) {struct sembuf sem_b;sem_b.sem_num = 0;sem_b.sem_op = -1;sem_b.sem_flg = SEM_UNDO;if (semop(sem_id, &sem_b, 1) == -1) {fprintf(stderr, "semaphore_p failed\n");return 0;}return 1;
}int semaphore_v(int sem_id) {struct sembuf sem_b;sem_b.sem_num = 0;sem_b.sem_op = 1;sem_b.sem_flg = SEM_UNDO;if (semop(sem_id, &sem_b, 1) == -1) {fprintf(stderr, "semaphore_v failed\n");return 0;}return 1;
}int main() {int shmid, sem_id;void *shm = NULL;struct shared_use_st *shared;// 创建共享内存shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);if (shmid == -1) {fprintf(stderr, "shmget failed\n");exit(EXIT_FAILURE);}// 将共享内存连接到当前进程的地址空间shm = shmat(shmid, 0, 0);if (shm == (void *)-1) {fprintf(stderr, "shmat failed\n");exit(EXIT_FAILURE);}// 新建信号量sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);// 信号量初始化if (!set_semvalue(sem_id)) {fprintf(stderr, "init failed.\n");exit(EXIT_FAILURE);}// 操作共享内存shared = (struct shared_use_st *) shm;// 写入数据strcpy(shared->text, "Data to be shared");semaphore_v(sem_id);// 读取数据semaphore_p(sem_id);printf("Read from shared memory: %s\n", shared->text);// 删除信号量del_semvalue(sem_id);// 把共享内存从当前进程中分离if (shmdt(shm) == -1) {fprintf(stderr, "shmdt failed\n");exit(EXIT_FAILURE);}// 删除共享内存if (shmctl(shmid, IPC_RMID, 0) == -1) {fprintf(stderr, "shmctl(IPC_RMID) failed");exit(EXIT_FAILURE);}exit(EXIT_SUCCESS);
}

共享内存：进程间的 “共享空间”

共享内存允许多个进程访问同一内存区域，是一种高效的 IPC 机制。可以使用 shmget、shmat、shmdt 和 shmctl 函数来创建共享内存、写入数据和读取数据。以下是创建共享内存、写入数据和读取数据的代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>#define TEXT_SZ 2048struct shared_use_st {char text[TEXT_SZ];
};int main() {int shmid;void *shm = NULL;struct shared_use_st *shared;// 创建共享内存shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);if (shmid == -1) {fprintf(stderr, "shmget failed\n");exit(EXIT_FAILURE);}// 将共享内存连接到当前进程的地址空间shm = shmat(shmid, 0, 0);if (shm == (void *)-1) {fprintf(stderr, "shmat failed\n");exit(EXIT_FAILURE);}// 设置共享内存shared = (struct shared_use_st *) shm;// 写入数据strcpy(shared->text, "Data to be shared");// 读取数据printf("Read from shared memory: %s\n", shared->text);// 把共享内存从当前进程中分离if (shmdt(shm) == -1) {fprintf(stderr, "shmdt failed\n");exit(EXIT_FAILURE);}// 删除共享内存if (shmctl(shmid, IPC_RMID, 0) == -1) {fprintf(stderr, "shmctl(IPC_RMID) failed");exit(EXIT_FAILURE);}exit(EXIT_SUCCESS);
}

消息队列：进程间的 “邮局”

消息队列允许进程发送和接收消息。可以使用 msgget、msgsnd 和 msgrcv 函数来创建消息队列、发送消息和接收消息。以下是创建消息队列、发送消息和接收消息的代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>#define MSG_SIZE 100struct msgbuf {long mtype;char mtext[MSG_SIZE];
};int main() {int msgid;key_t key = ftok(".", 'm');// 创建消息队列msgid = msgget(key, 0666 | IPC_CREAT);if (msgid == -1) {perror("msgget");exit(1);}// 发送消息struct msgbuf sendbuf;sendbuf.mtype = 1;strcpy(sendbuf.mtext, "Hello from message queue!");if (msgsnd(msgid, &sendbuf, strlen(sendbuf.mtext) + 1, 0) == -1) {perror("msgsnd");exit(1);}// 接收消息struct msgbuf recvbuf;if (msgrcv(msgid, &recvbuf, MSG_SIZE, 1, 0) == -1) {perror("msgrcv");exit(1);}printf("Received message: %s\n", recvbuf.mtext);// 删除消息队列if (msgctl(msgid, IPC_RMID, NULL) == -1) {perror("msgctl");exit(1);}return 0;
}

套接字：跨网络的 “通信使者”

套接字是一种网络通信机制，也可用于本地 IPC。可以使用 socket、bind、listen、accept 和 connect 函数来实现服务端和客户端的通信。以下是服务端和客户端的代码示例：

服务端：

#include <iostream>
#include <string.h>
#include <unistd.h> // for close()
#include <arpa/inet.h> // for sockaddr_in, inet_addr
#include <sys/types.h>
#include <sys/socket.h>#define PORT 8080
#define BUFFER_SIZE 1024int main() {int server_fd, new_socket;struct sockaddr_in address;int opt = 1;int addrlen = sizeof(address);char buffer[BUFFER_SIZE] = {0};// 创建 socket 文件描述符if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {perror("socket failed");exit(EXIT_FAILURE);}// 将套接字绑定到端口if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {perror("setsockopt");exit(EXIT_FAILURE);}address.sin_family = AF_INET;address.sin_addr.s_addr = INADDR_ANY; // 接受任何地址address.sin_port = htons(PORT); // 转换为网络字节序if (bind(server_fd, (struct sockaddr *)&address, sizeof(address))<0) {perror("bind failed");exit(EXIT_FAILURE);}// 开始监听if (listen(server_fd, 3) < 0) {perror("listen");exit(EXIT_FAILURE);}std::cout << "Server is listening on port " << PORT << std::endl;// 接受客户端连接if ((new_socket = accept(server_fd, (struct sockaddr *)&address,(socklen_t*)&addrlen))<0) {perror("accept");exit(EXIT_FAILURE);}// 接收数据read(new_socket , buffer, BUFFER_SIZE);std::cout << "Message from client: " << buffer << std::endl;const char *hello = "Hello from server";send(new_socket , hello , strlen(hello) , 0 );std::cout << "Hello message sent" << std::endl;close(new_socket);close(server_fd);return 0;
}

客户端代码：

#include <iostream>
#include <string.h>
#include <unistd.h> // for close()
#include <arpa/inet.h> // for sockaddr_in, inet_addr#define PORT 8080int main() {int sock = 0; struct sockaddr_in serv_addr; char *hello = "Hello from client"; char buffer[1024] = {0};// 创建套接字文件描述符 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { std::cerr << "\n Socket creation error \n"; return -1; } serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(PORT); // 将 IPv4 地址从文本转换为二进制形式 if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) { std::cerr << "\nInvalid address/ Address not supported \n"; return -1; } // 发起连接请求  if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { std::cerr << "\nConnection Failed \n"; return -1; } send(sock , hello , strlen(hello) , 0 );  std::cout << "Hello message sent from client" << std::endl; read(sock , buffer, sizeof(buffer));  std::cout << "Message from server: " << buffer << std::endl;close(sock);return 0; 
}

编译与运行