Linux网络编程（九）——进程间通信_linux进程间通信和网络编程-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_60875396/article/details/146350028

文章目录

9 进程间通信

9.1 进程间通信的概念

进程具有完全独立的内存结构，就连通过 fork 函数创建的子进程也不会与父进程共享内存空间。如果多个进程之间需要信息交换，常用方法如下：

Unix Domain Socket IPC（套接字通信）
管道（有名管道、匿名管道）
共享内存
消息队列
信号量

由于篇幅参考书籍只介绍了匿名管道（pipe）

9.1.1 通过匿名管道实现进程间通信

管道并非属于进程的资源，而是和套接字一样，属于操作系统（也就不是 fork 函数的复制对象）。所以，两个进程通过操作系统提供的内存空间进行通信。匿名管道是位于内核的一块缓冲区，用于进程间通信。创建匿名管道的系统调用为 pipe()。

#include<unistd.h>
int pipe (int __pipedes[2])    
/**
* int __pipedes[2]：pipefd[0]为读端的文件描述符，pipefd[1]为写端的文件描述符
* return：成功返回0  失败返回-1
*/

以长度为 2 的 int 数组地址值作为参数调用上述函数时，数组中存有两个文件描述符，它们将被用作管道的出口和人口。调用 fork 函数之前要创建好管道，同时获取对应于出人口的文件描述符，此时父进程可以读写同一管道。但父进程的目的是与子进程进行数据交换，因此需要将人口或出口中的1个文件描述符传递给子进程。我们将通过下列示例进行演示。

#define BUF_SIZE 1024

int main(int argc, char const *argv[])
{
    char* message = malloc(sizeof(char)*BUF_SIZE);
    char str[] = "Who are you?\n";
    //创建管道
    int pipefd[2];
    if(pipe(pipefd)<0) {
        perror("创建管道失败");
        exit(EXIT_FAILURE);
    }
    pid_t pid = fork();
    if(pid<0)  exit(EXIT_FAILURE);
    else if(pid==0) {
        //子进程    写入管道数据，提供给父进程
        close(pipefd[0]);    //关闭读端
        //将数据写入管道的写端    
        write(pipefd[1],str,sizeof(str));
        close(pipefd[1]);    //关闭写端
    }
    else {
        //父进程    读取管道数据 打印到控制台
        close(pipefd[1]);    //关闭写端
        //从读端读取数据，打印到控制台
        read(pipefd[0],message,BUF_SIZE);
        fputs(message,stdout);
        close(pipefd[0]);    //关闭读端
        //等待子进程结束
        waitpid(pid,NULL,0);
    }
    return 0;
}

9.1.2 通过管道进行进程间双向通信

两个进程通过一个管道只能实现单向通信（半双工），例如上面的例子，父进程读子进程写，如果有时候也需要父进程写子进程读，就必须另开一个管道，父子进程各自负责不同的数据流动即可。

#define BUF_SIZE 1024

int main(int argc, char const *argv[])
{
    int fds1[2],fds2[2];
    char str1[] = "Who are you?";
    char str2[] = "Thank you for your message";
    char* message = malloc(sizeof(char)*BUF_SIZE);
    if(pipe(fds1)<0 || pipe(fds2)<0) {
        perror("创建管道失败");
        exit(EXIT_FAILURE);
    }

    pid_t pid = fork();
    if(pid<0)  exit(EXIT_FAILURE);
    else if(pid==0) {
        //子进程    写入管道数据，提供给父进程
        close(fds1[0]);close(fds2[1]);
        write(fds1[1],str1,sizeof(str1));
        read(fds2[0],message,BUF_SIZE);
        close(fds1[1]);close(fds2[0]);
        printf("Child proc output:%s\n",message);
    }
    else {
        //父进程    读取管道数据 打印到控制台
        close(fds1[1]);close(fds2[0]);
        read(fds1[0],message,BUF_SIZE);
        printf("Parent proc output:%s\n",message);
        write(fds2[1],str2,sizeof(str2));
        close(fds1[0]);close(fds2[1]);
        //等待子进程结束
        waitpid(pid,NULL,0);
    }
    return 0;
}

9.2 运用进程间通信

9.2.1 保存消息的回声服务器

我们在回声服务器的基础上添加功能：将回声客户端传输的字符串按序保存到文件中，该任务会被委托给另外的进程。

#define BUF_SIZE 1024
#define handle_error(cmd,result)    \
    if(result < 0)                  \
    {                               \
        perror(cmd);                \
        return -1;                  \
    }                               \

void head_childproc(int sig) {
    pid_t pid;
    int status;
    pid = waitpid(-1,&status,WNOHANG);
    printf("removed proc id:%d\n",pid);
}

int main(int argc, char const *argv[])
{
    struct sigaction act; 
    struct sockaddr_in serv_addr,clnt_addr;
    char* buf = malloc(sizeof(char)*BUF_SIZE);
    memset(buf,0,sizeof(buf));
    memset(&serv_addr,0,sizeof(serv_addr));
    memset(&clnt_addr,0,sizeof(serv_addr));
    if(argc != 2) {
        printf("Usage：%s <port>\n",argv[0]);
        exit(1);
    }

    //注册信号，子进程运行结束执行函数
    act.sa_handler = head_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD,&act,0);

    //套接字流程
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(atoi(argv[1]));
    inet_pton(AF_INET,"0.0.0.0",&serv_addr.sin_addr);
    int serv_sock = socket(AF_INET,SOCK_STREAM,0);
    handle_error("socket",serv_sock);
    //设置地址在分配
    int option = 1;
    int optlen = sizeof(option);
    setsockopt(serv_sock,SOL_SOCKET,SO_REUSEADDR,(void *)&option, optlen);
    int temp=bind(serv_sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
    handle_error("bind",temp);
    temp= listen(serv_sock,128);
    handle_error("listen",temp);

    int fds[2];
    if(pipe(fds)<0) {
        perror("创建管道失败");
        exit(EXIT_FAILURE);
    }
    pid_t pid = fork();
    if(pid<0)  return 1;
    else if(pid==0) {
        //子进程    从管道读取数据，将读取到的前10条数据记录在echomsg.txt中
        int fd = open("echomsg.txt",O_RDWR|O_CREAT|O_APPEND,0664);
        char msgbuf[BUF_SIZE];
        close(fds[1]);
        for(int i = 0;i < 10;i++) {
            //如果管道内没有数据，读操作会被阻塞
            int len = read(fds[0],msgbuf,BUF_SIZE);
            write(fd, msgbuf, len); 
        }
        close(fds[0]);
        close(fd);
        return 0;
    }
    else {
        //父进程    循环接发客户端的数据
        while(1) {
            int str_len;
            socklen_t clnt_len = sizeof(clnt_addr);
            int clnt_sock=accept(serv_sock,(struct sockaddr*)&clnt_addr,&clnt_len);
            if(clnt_sock==-1) continue;
            else puts("new client connected...");
            pid = fork();
            if(pid<0)  return 1;
            else if(pid==0) {
                //子进程    接发客户端的数据，并把收到的数据写入管道保存起来
                close(serv_sock);
                close(fds[0]);
                while((str_len=recv(clnt_sock,buf,BUF_SIZE,0))!=0) {  
                    //如果管道数据已满，写操作会被阻塞           
                    write(fds[1],buf,str_len); 
                    send(clnt_sock,buf,str_len,0);
                }
                close(fds[1]);
                close(clnt_sock);
                puts("client disconnected...");
                return 0;
            }
            else {
                //父进程    什么也不做
                close(clnt_sock);
            }
        }
    }
    close(serv_sock);
    free(buf);
    return 0;
}