关于进程间通信的内容，查看这里：§ 使用 pipe 进程间通信 · 语雀 (yuque.com)

现在将进程间通信方法运用到网络代码中，可以创建一个功能更加强大的服务器。

保存消息的回声服务器端

之前，我们创建过一个回声服务器端。这里我们加一个要实现的功能：将客户端传输过来的字符串保存到文件中。

服务器端 客户端
V00：回声 发送字符串
v01：多进程，父进程负责读，子进程负责写，
使用 sigaction 信号机制消灭僵尸进程		 发送字符串
v02：保存消息，使用 pipe 实现进程间通信 发送字符串

我们将该任务委托给另外的进程。创建另外的进程，从向客户端提供服务的进程读取字符串消息。

下面是示例代码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <sys/wait.h>
  6. #include <arpa/inet.h>
  7. #include <sys/socket.h>
  9. #define BUF_SIZE 100
  10. void error_handling(char *message);
  11. void read_childproc(int sig);
  13. int main(int argc, char *argv[]) {
  14.     int serv_sock, clnt_sock;
  15.     struct sockaddr_in serv_adr, clnt_adr;
  16.     int fds[2];
  18.     pid_t pid;
  19.     struct sigaction act;
  20.     socklen_t adr_sz;
  21.     int str_len, state;
  22.     char buf[BUF_SIZE];
  23.     if (argc != 2) {
  24.         printf("Usage: %s <port> \n", argv[0]);
  25.         exit(1);
  26.     }
  28.     // 使用信号机制
  29.     act.sa_handler = read_childproc;
  30.     sigemptyset(&act.sa_mask);
  31.     act.sa_flags = 0;
  32.     state = sigaction(SIGCHLD, &act, 0);
  34.     // 建立套接字
  35.     serv_sock = socket(PF_INET, SOCK_STREAM, 0);
  36.     memset(&serv_adr, 0, sizeof(serv_adr));
  37.     serv_adr.sin_family = AF_INET;
  38.     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
  39.     serv_adr.sin_port = htons(atoi(argv[1]));
  42.     // bind与本地连接
  43.     if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
  44.         error_handling("bind() error");
  46.     // listen监听状态
  47.     if (listen(serv_sock, 5) == -1)
  48.         error_handling("listen() error");
  50.     // 使用 pipe 管道实现进程间通信 
  51.     pipe(fds);
  53.     // 用于保存文件的子进程1
  54.     pid = fork();                
  55.     if (pid == 0) {
  56.         FILE *fp = fopen("echomsg.txt", "wt");
  57.         char msgbuf[BUF_SIZE];
  58.         int i, len;
  60.         for (i=0; i<10; i++) {
  61.             len = read(fds[0], msgbuf, BUF_SIZE);        // 向内存中读取消息
  62.             fwrite((void*) msgbuf, 1, len, fp);
  63.         }
  64.         fclose(fp);
  65.         return 0;
  66.     }
  67.     while(1) {
  68.         // 主进程负责读
  69.         adr_sz = sizeof(clnt_adr);
  70.         clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
  71.         if (clnt_sock == -1)
  72.             continue;
  73.         else
  74.             puts("new client connected...");
  76.         // 用于向客户端发送回声的子进程2
  77.         pid = fork();
  78.         if (pid == 0) {
  79.             close(serv_sock);
  80.             while((str_len=read(clnt_sock, buf, BUF_SIZE)) != 0) {
  81.                 write(clnt_sock, buf, str_len);            // 向内存中写信息
  82.                 write(fds[1], buf, str_len);
  83.             }
  84.             close(clnt_sock);            // 关闭子进程2的套接字描述符
  85.             puts("client disconnected...");
  86.             return 0;
  87.         }
  88.         else close(clnt_sock);            // 关闭主进程的套接字描述符
  89.     }
  90.     close(serv_sock);                    // 关闭子进程1的套接字描述符
  91.     return 0;
  92. }
  94. void read_childproc(int sig) {
  95.     pid_t pid;
  96.     int status;
  97.     pid = waitpid(-1, &status, WNOHANG);
  98.     printf("removed proc id: %d \n", pid);
  99. }
  101. void error_handling(char *message) {
  102.     fputs(message, stderr);
  103.     fputc('\n', stderr);
  104.     exit(1);
  105. }

这个程序所拥有的模块如下：

§ 使用进程间通信建立服务器 - 图1

如果想构建更大型的程序

前面讲解了并发服务器的实现模型，至此，可能大家心里会有新的想法，比如：

我想利用进程和管道编写聊天室程序，使得多个客户端进行通话，应该从哪着手呢？

如果仅用进程和管道构建具有复杂功能的服务器端，程序员需要有相当熟练的编程经验。因此，以后还会学到其他的模型扩展，我们之前学习的东西只是搭建复杂模型的第一步。