TCP/IP网络编程(9) 进程间通信
1. IPC基本概念
进程间通信(Inter process communication, IPC)以为这两个不同进程间可以交换数据，为了完成这一点，操作系统中应该提供两个进程可以同时访问的内存空间。因此，只要有两个进程可以同时访问的内存空间，就可以通过此空间来交换数据。但是，进程具有完全独立的内存结构，即使通过fork()函数创建的子进程，也不会与父进程共享内存，因此进程间通信需要通过其他的特殊方法完成。
1.1 利用管道实现进程间通信
为完成进程之间的通信，需要创建管道，管道不属于进程的资源(即不是fork复制的对象)，而是和套接字一样，属于操作系统资源，因此通过管道首实现IPC的原理是，两个进程通过操作系统提供的内存进行通信。
创建管道的方式：
#include <unistd.h>
/*
成功时返回0
失败时返回-1
参数：
fields[0] 通过管道接收数据时使用的文件描述符
fields[1] 通过管道传输数据时使用的文件描述符
*/
int pipe(int fields[2]);
父进程调用pipe函数时将创建管道，同时获取对应于管道出入口的文件描述符，此时父进程可以读写同一管道，在调用fork创建子进程之后，子进程也将同时拥有管道出入口的文件描述符：
#include <stdio.h>
#include <unistd.h>
#define BUFF_SIZE 30
int main(int argc, char** argv)
{
int fds[2]; // 用于存储管道出入口的文件描述符
char message[] = "Hello Process\n";
char buffer[BUFF_SIZE];
if (pipe(fds) == -1)
{
printf("Falied to create pipe.\n");
return -1;
}
pid_t pid = fork(); // 创建进行
if (pid == 0)
{
// 子进程 写入管道
write(fds[1], message, sizeof(message));
}
else
{
// 父进程 读取管道
read(fds[0], buffer, BUFF_SIZE);
fputs(buffer, stdout);
}
return 0;
}进程间通信的示意图图下所示：
1.2 通过管道实现进程间双向通信
方案1：通过一个管道实现两个进程间的双向通信
代码实例：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#define BUFF_SIZE 30
int main(int argc, char** argv)
{
int fds[2]; // 用于存储管道出入口的文件描述符
char message1[] = "Hello Process\n";
char message2[] = "I am vac!\n";
char buffer[BUFF_SIZE];
memset(buffer, 0, BUFF_SIZE);
if (pipe(fds) == -1)
{
printf("Falied to create pipe.\n");
return -1;
}
pid_t pid = fork(); // 创建进行
if (pid == 0)
{
// 子进程 写入管道
write(fds[1], message1, sizeof(message1));
sleep(2);
read(fds[0], buffer, BUFF_SIZE);
printf("Child proc received data: %s\n", buffer);
memset(buffer, 0, BUFF_SIZE);
}
else
{
// 父进程 读取管道
read(fds[0], buffer, BUFF_SIZE);
printf("Parent proc received data: %s\n", buffer);
write(fds[1], message2, sizeof(message2));
sleep(3);
memset(buffer, 0, BUFF_SIZE);
}
return 0;
}运行结果：
如果将子进程中的sleep方法注释掉，再运行代码：
if (pid == 0)
{
// 子进程 写入管道
write(fds[1], message1, sizeof(message1));
//sleep(2);
read(fds[0], buffer, BUFF_SIZE);
printf("Child proc received data: %s\n", buffer);
memset(buffer, 0, BUFF_SIZE);
}结果如下所示：
此时父进程无法再收到数据，因为子进程在写入数据后，未经过延时，立即又读取数据，因此管道中写入的数据被子进程提前取走。按照管道数据的读取机制，数据在写入管道之后，称为无主数据，哪个进程先通过read函数读取数据，哪个进程就先得到数据。结果导致父进程通过read函数再也读取不到数据，而将无限期等待管道数据。
注：利用一个管道进行进程间数据双向通信，程序设计者需要提前预测并控制运行流程，程序实现难度很大。
方案2：通过两个管道实现进程间相互通信
通过创建两个管道，各自在进程间负责不同的数据流，即可方便的实现进程间双向通信，采用两个管道即可避免程序运行流程的预测或控制。
代码实例：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#define BUFF_SIZE 30
int main(int argc, char** argv)
{
int fds1[2]; // 子进程向父进程写数据
int fds2[2]; // 父进程向子进程写数据
char message1[] = "Hello Process\n";
char message2[] = "I am vac!\n";
char buffer[BUFF_SIZE];
memset(buffer, 0, BUFF_SIZE);
if (pipe(fds1) == -1)
{
printf("Falied to create pipe.\n");
return -1;
}
if (pipe(fds2) == -1)
{
printf("Falied to create pipe.\n");
return -1;
}
pid_t pid = fork(); // 创建进行
if (pid == 0)
{
// 子进程 写入管道
write(fds1[1], message1, sizeof(message1));
read(fds2[0], buffer, BUFF_SIZE);
printf("Child proc received data: %s\n", buffer);
memset(buffer, 0, BUFF_SIZE);
}
else
{
// 父进程 读取管道
sleep(1); // 可以延时更短，稍微等待一下
read(fds1[0], buffer, BUFF_SIZE);
printf("Parent proc received data: %s\n", buffer);
write(fds2[1], message2, sizeof(message2));
memset(buffer, 0, BUFF_SIZE);
}
return 0;
}运行结果：
2. 进程间通信的应用
保存消息的回声服务器: 在向客户端提供服务的同时，服务端能够将接收到的数据同步保存到文件中。
客户端代码可复用《TCP/IP网络编程(8) 基于Linux的多进程服务器》中的客户端代码
/*
客户端
create_date: 2022-7-29
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUFF_SIZE 30
#define ADDRESS "127.0.0.1"
#define PORT 13100
void readRoutine(int sock, char* buf);
void writeRoutine(int sock, char* buf);
int main(int argc, char** argv)
{
char buffer[BUFF_SIZE];
struct sockaddr_in serverAddr; // 服务端地址
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = inet_addr(ADDRESS);
serverAddr.sin_port = htons(PORT);
memset(buffer, 0, BUFF_SIZE);
int socket = ::socket(PF_INET, SOCK_STREAM, 0);
if (socket == -1)
{
printf("Failed to init socket.\n");
return -1;
}
if (connect(socket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1)
{
printf("Failed to connect to server.\n");
return -2;
}
printf("Successfully connect to the server.\n");
pid_t pid = fork();
if (pid == 0)
{
// 子进程负责发送
writeRoutine(socket, buffer);
}
else
{
// 父进程负责接收
readRoutine(socket, buffer);
}
close(socket);
return 0;
}
void readRoutine(int sock, char* buf)
{
while (true)
{
memset(buf, 0, BUFF_SIZE);
int str_len = read(sock, buf, BUFF_SIZE);
if (str_len == 0) // EOF
{
printf("Receive EOF\n");
return;
}
printf("\nReceive data from server: %s\n", buf);
}
}
void writeRoutine(int sock, char* buf)
{
while (true)
{
fputs("Input message(Type Q(q) to quit): ", stdout);
fgets(buf, BUFF_SIZE, stdin);
if (strncmp(buf, "Q\n", 2) == 0 || strncmp(buf, "q\n", 2) == 0)
{
shutdown(sock, SHUT_WR);
return;
}
write(sock, buf, strlen(buf));
}
}服务端示例代码代码示例：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/wait.h>
void readChildProcess(int signo)
{
int status;
pid_t pid = waitpid(-1, &status, WNOHANG); // 非阻塞
if (WIFEXITED(status))
{
printf("Removed child process %d\n", WEXITSTATUS(status));
}
}
#define BUFF_SIZE 30
#define PORT 13100
int main(int argc, char** argv)
{
int serverSocket;
int clientSocket;
struct sockaddr_in servAddr;
struct sockaddr_in clientAddr;
char buffer[BUFF_SIZE];
memset(buffer, 0, BUFF_SIZE);
socklen_t addrSize;
int fds[2]; // 管道的文件描述符
struct sigaction sigact;
sigact.sa_handler = readChildProcess;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaction(SIGCHLD, &sigact, 0); // 注册信号
serverSocket = socket(PF_INET, SOCK_STREAM, 0);
if (serverSocket == -1)
{
printf("Failed to init server socket.\n");
return -1;
}
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
servAddr.sin_port = htons(PORT);
if (bind(serverSocket, (struct sockaddr*)&servAddr, sizeof(servAddr)) == -1)
{
printf("Failed to bind the server socket.\n");
return -1;
}
if (listen(serverSocket, 5) == -1)
{
printf("Failed to listen client.\n");
return -1;
}
// 创建管道
pipe(fds);
// 创建写文件进程
pid_t pid = fork();
if (pid == 0)
{
// 写文件子进程
FILE* fp = fopen("data.txt", "a");
char msg[100];
while (true)
{
/* code */
usleep(1000*40);
memset(msg, 0, 100);
int len = read(fds[0], msg, 100);
// 解析读取到的内容
if (len <= 5)
{
break;
}
char magicChar1 = msg[0];
char magicChar2 = msg[1];
if (magicChar1 != 'M' || magicChar2 != 'F')
{
break;
}
if (msg[2] == 1)
{
break;
}
ushort dataLen = msg[3] | (msg[4] << 8);
if (dataLen <= 0)
{
continue;
}
// 将解析到的内容写入文件进行保存
fwrite(&msg[5], dataLen, 1, fp);
}
fclose(fp);
return 0;
}
else
{
// 父进程
while (true)
{
printf("Waiting connect from client...\n");
addrSize = sizeof(clientAddr);
clientSocket = accept(serverSocket, (sockaddr*)&clientAddr, &addrSize);
if (clientSocket == -1)
continue;
printf("Accept new connection from %s:%d.\n", inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));
pid_t processId = fork();
if (processId == 0)
{
// 子进程
close(serverSocket);
// 接受消息
int recvLen = 0;
// 构造报文
char message[100];
usleep(1000*100);
while ((recvLen = read(clientSocket, buffer, BUFF_SIZE)) != 0)
{
/* code */
write(clientSocket, buffer, recvLen);
// 向管道写数据
memset(message, 0, 100);
message[0] = 'M';
message[1] = 'F';
message[2] = 0;
message[3] = recvLen & 0xFF;
message[4] = (recvLen >> 8) & 0xFF;
memcpy(&message[5], buffer, recvLen); // 注意：memcpy里面的指针不要转换成void*
write(fds[1], message, recvLen + 5);
memset(buffer, 0, BUFF_SIZE);
}
close(clientSocket);
memset(message, 0, 100);
// 发送结束标志
message[0] = 'M';
message[1] = 'F';
message[2] = 1;
message[3] = 0;
message[4] = 0;
write(fds[1], (void*)message, 5);
printf("Disconnecting from server...\n");
sleep(2);
return 0;
}
else if (processId == -1)
{
close(clientSocket);
continue;
}
else
{
// 主进程
printf("Create new process %d for client.\n", processId);
close(clientSocket);
memset(&clientAddr, 0, sizeof(clientAddr));
continue;
}
}
}
close(serverSocket);
return 0;
}
/*
服务器进程和文件进程之间设计通信格式
0 M // 报文头
1 F // 报文头
2 0/1 // 报文类型 0数据 / 1 结束
3 len // 数据长度 低位
4 len // 数据长度 高位
5 x // 数据
6 x // 数据
7 x // 数据
. // .
.
.
*/客户端运行结果：
服务端运行结果：
通过管道进行进程间通信，将服务端收到的消息发送给写文件进程，将收到的消息保存至文件：
-----------------------------------------//end//---------------------------------------------
浙公网安备 33010602011771号