系统相关
首页 > 系统相关> > [Linux 高并发服务器] 管道

[Linux 高并发服务器] 管道

作者:互联网

[Linux 高并发服务器] 管道

这个博客是根据牛客的C++项目课程写的笔记

什么是管道

管道也叫做无名(匿名)管道,是UNIX系统IPC进程间通信的最古老形式,所有UNIX系统都支持这种通信机制。(一般说管道就是说匿名管道,但是还有有名管道,做个区分)

统计目录文件数

管道的特点

tips补充:
单工:指数据传输只支持数据在一个方向上传输

双工:指二台通讯设备之间,允许有双向的资料传输。通常有两种双工模式。一种叫半双工,另一种叫全双工

全双工:(full-duplex)的系统允许二台设备间同时进行双向数据传输。一般的电话、手机就是全双工的系统,因为在讲话时同时也可以听到对方的声音。

半双工:(half-duplex)的系统允许二台设备之间的双向数据传输,但不能同时进行。因此同一时间只允许一设备传送资料,若另一设备要传送资料,需等原来传送资料的设备传送完成后再处理。

为什么可以使用管道进行进程间通信

可以从文件描述符的角度来看,对于两个亲缘关系的进程,他们往往共享一个文件描述符号表,因此他们可以对同一个文件进行读写操作。
管道不过是把文件描述符表的文件换成了管道。
在这里插入图片描述对于上图而言,左边进程文件描述符5指向管道写入端,6指向管道读取端这件事同样发生在fork出来的子进程当中,因此他们可以通过管道进行进程间通信(例如父进程从5写入,子进程从6读取)
在这里插入图片描述

管道的数据结构

管道的数据结构在逻辑上是一个循环队列。
好处就是能避免普通队列假溢出问题,有效利用空间。
当然这是逻辑上的,内存上并非环形的。
管道的数据结构造成了管道的很多性质,比如只能读取一次啊,不能lseek随机访问啊之类的
在这里插入图片描述

管道的使用

匿名管道的使用

/*
    #include <unistd.h>
    int pipe(int pipefd[2]);
        功能:创建一个匿名管道,用来进程间通信。
        参数:int pipefd[2] 这个数组是一个传出参数。
            pipefd[0] 对应的是管道的读端
            pipefd[1] 对应的是管道的写端
        返回值:
            成功 0
            失败 -1

    管道默认是阻塞的:如果管道中没有数据,read阻塞,如果管道满了,write阻塞

    注意:匿名管道只能用于具有关系的进程之间的通信(父子进程,兄弟进程)
*/

// 子进程发送数据给父进程,父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

    // 在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};
        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("parent recv : %s, pid : %d\n", buf, getpid());
            
            // 向管道中写入数据
            //char * str = "hello,i am parent";
            //write(pipefd[1], str, strlen(str));
            //sleep(1);
        }

    } else if(pid == 0){
        // 子进程
        printf("i am child process, pid : %d\n", getpid());
        // 关闭读端
        close(pipefd[0]);
        char buf[1024] = {0};
        while(1) {
            // 向管道中写入数据
            char * str = "hello,i am child";
            write(pipefd[1], str, strlen(str));
            sleep(1);

             //int len = read(pipefd[0], buf, sizeof(buf));
             //printf("child recv : %s, pid : %d\n", buf, getpid());
             //bzero(buf, 1024);
        }
        
    }
    return 0;
}

在这里插入图片描述上面的程序有几个需要注意的点
1.read函数是阻塞的,所以如果你不往管道写入数据他是不会读的,因此父子进程读和写顺序不能相同,不然两个进程都在read函数阻塞了走不下去
2.每次写了数据后要清空buf,不然会出问题
3.被注释掉的部分,如果不加sleep,那么有可能父进程还没被CPU分配时间片,子进程就继续往下执行了,造成子进程读自己的写自己的情况(反过来的话就是父进程读自己写入的数据)
4.由于第三点,匿名管道一般不用来进行双向的通信,数据流向一般单向,我们一般会事先用close关闭父进程写端,子进程读端(对于这个例子而言)

获取管道大小

我们可以使用ulmit -a来查看并设置管道大小,当然我们也可以使用fpathconf函数来获取

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

    int pipefd[2];

    int ret = pipe(pipefd);

    // 获取管道的大小
    long size = fpathconf(pipefd[0], _PC_PIPE_BUF);

    printf("pipe size : %ld\n", size);

    return 0;
}

管道的读写特点

使用管道时,需要注意以下几种特殊的情况(假设都是阻塞I/O操作)
1.所有的指向管道写端的文件描述符都关闭了(管道写端引用计数为0),有进程从管道的读端
读数据,那么管道中剩余的数据被读取以后,再次read会返回0,就像读到文件末尾一样。

2.如果有指向管道写端的文件描述符没有关闭(管道的写端引用计数大于0),而持有管道写端的进程也没有往管道中写数据,这个时候有进程从管道中读取数据,那么管道中剩余的数据被读取后,再次read会阻塞,直到管道中有数据可以读了才读取数据并返回。

3.如果所有指向管道读端的文件描述符都关闭了(管道的读端引用计数为0),这个时候有进程
向管道中写数据,那么该进程会收到一个信号SIGPIPE, 通常会导致进程异常终止。

4.如果有指向管道读端的文件描述符没有关闭(管道的读端引用计数大于0),而持有管道读端的进程也没有从管道中读数据,这时有进程向管道中写数据,那么在管道被写满的时候再次write会阻塞,直到管道中有空位置才能再次写入数据并返回。

总结:

读管道:
    管道中有数据,read返回实际读到的字节数。
    管道中无数据:
    写端被全部关闭,read返回0(相当于读到文件的末尾)
    写端没有完全关闭,read阻塞等待
写管道:
    管道读端全部被关闭,进程异常终止(进程收到SIGPIPE信号)
    管道读端没有全部关闭:
        管道已满,write阻塞
        管道没有满,write将数据写入,并返回实际写入的字节数

因此,进行逛到读写的时候要考虑清楚,读端写端的开启和关闭,如果读入过量数据会发生什么,是否需要循环多次读写

管道设置为非阻塞

管道的读端写端可以看作文件描述符,所以我们可以使用fctnl函数来设置管道是否阻塞。
首先获取原来的文件描述符的状态,然后让状态值或上非阻塞的宏得到新的文件描述符状态,最后重新设置文件描述符状态

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
/*
    设置管道非阻塞
    int flags = fcntl(fd[0], F_GETFL);  // 获取原来的flag
    flags |= O_NONBLOCK;            // 修改flag的值
    fcntl(fd[0], F_SETFL, flags);   // 设置新的flag
*/
int main() {

    // 在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};

        int flags = fcntl(pipefd[0], F_GETFL);  // 获取原来的flag
        flags |= O_NONBLOCK;            // 修改flag的值
        fcntl(pipefd[0], F_SETFL, flags);   // 设置新的flag

        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("len : %d\n", len);
            printf("parent recv : %s, pid : %d\n", buf, getpid());
            memset(buf, 0, 1024);
            sleep(1);
        }

    } else if(pid == 0){
        // 子进程
        printf("i am child process, pid : %d\n", getpid());
        // 关闭读端
        close(pipefd[0]);
        char buf[1024] = {0};
        while(1) {
            // 向管道中写入数据
            char * str = "hello,i am child";
            write(pipefd[1], str, strlen(str));
            sleep(5);
        }
        
    }
    return 0;
}



在这里插入图片描述
子进程写入数据后,管道内有数据,父进程正常读数据。但是后面由于子进程sleep没有马上写入数据,管道内没有数据,父进程read原本应该被阻塞,但是因为我们设置了管道非阻塞,所以还是一直在读取。

有名管道

有名管道介绍

由于匿名管道没有名字,只能用于有亲缘关系的进程之间通信。为了克服这个缺点,出现了有名管道FIFO,也叫FIFO文件、命名管道

有名管道提供了一个路径名与之关联,以FIFO文件的形式存在于文件系统之中,打开方式和普通文件一样,所以与FIFO的创建进程不存在亲缘关系的进程只要能访问该路径,就能通过FIFO相互通信

一旦打开FIFO,操作基本就和匿名管道的操作一样了,同时也匿名管道一样有一个读端和一个写端,数据读取顺序和写入顺序一样

与匿名管道的区别

1.FIFO在文件系统中作为一个特殊文件存在,但FIFO中的内容却存在内存中
2.当时用FIFO的进程退出后,FIFO文件继续保存在文件系统中,以后也可以使用
3.FIFO有名字,不相关的进程可以打开有名管道通信

有名管道的使用

创建FIFO

/*
    创建fifo文件
    1.通过命令: mkfifo 名字
    2.通过函数:int mkfifo(const char *pathname, mode_t mode);

    #include <sys/types.h>
    #include <sys/stat.h>
    int mkfifo(const char *pathname, mode_t mode);
        参数:
            - pathname: 管道名称的路径
            - mode: 文件的权限 和 open 的 mode 是一样的
                    是一个八进制的数
        返回值:成功返回0,失败返回-1,并设置错误号

*/

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>

int main() {


    // 判断文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        printf("管道不存在,创建管道\n");
        
        ret = mkfifo("fifo1", 0664);

        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }       

    }
    return 0;
}

向管道写入数据

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

int main() {

    // 1.判断文件是否存在
    int ret = access("test", F_OK);
    if(ret == -1) {
        printf("管道不存在,创建管道\n");
        
        // 2.创建管道文件
        ret = mkfifo("test", 0664);

        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }       

    }

    // 3.以只写的方式打开管道
    int fd = open("test", O_WRONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 写数据
    for(int i = 0; i < 100; i++) {
        char buf[1024];
        sprintf(buf, "hello, %d\n", i);
        printf("write data : %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }

    close(fd);

    return 0;
}

因为使用只写模式打开了管道,没有读端口打开,所以目前管道还是阻塞的,不会往里面写数据,所以下面还要整一个读端。
读取数据

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

// 从管道中读取数据
int main() {

    // 1.打开管道文件
    int fd = open("test", O_RDONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 读数据
    while(1) {
        char buf[1024] = {0};
        int len = read(fd, buf, sizeof(buf));
        if(len == 0) {
            printf("写端断开连接了...\n");
            break;
        }
        printf("recv buf : %s\n", buf);
    }

    close(fd);

    return 0;
}

如果写端停掉,读端或报写端端口链接
如果读端停掉,写端会停下,产生信号了SIGPIPE

有名管道注意事项

1.一个为只读而打开一个管道的进程会阻塞,直到另外一个进程为只写打开管道
2.一个为只写而打开一个管道的进程会阻塞,直到另外一个进程为只读打开管道

读管道:
管道中有数据,read返回实际读到的字节数
管道中无数据:
管道写端被全部关闭,read返回0,(相当于读到文件末尾)
写端没有全部被关闭,read阻塞等待

写管道:
管道读端被全部关闭,进行异常终止(收到一个SIGPIPE信号)
管道读端没有全部关闭:
管道已经满了,write会阻塞
管道没有满,write将数据写入,并返回实际写入的字节数。

标签:int,pipefd,并发,管道,Linux,进程,服务器,include,buf
来源: https://blog.csdn.net/qq_39354847/article/details/120766212