管道机制

作者: lintong | 来源:发表于2015-03-02 14:06 被阅读1020次

    本文摘抄自linux基础编程

    管道指的是从一个进程连接数据流到另一个进程。它具有以下特点:

    • 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道
    • 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);
    • 单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统,并且只存在与内存中

    数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区的头部读出数据

    本文详细介绍管道相关信息。

    管道

    基于标准库popen和pclose的进程管道

    #include <stdio.h>  
    FILE *popen(const char *command, const char *type);  
    int pclose(FILE *stream);  
    

    popen允许一个程序将另一个程序作为新进程启动。并可以传递数据给它或者通过它接受数据。type仅能为"r"和“w”两种。当type="r"时,调用程序可以通过FILE文件流指针从被调用程序的输出获得数据;当type="w"时,调用程序可以通过fwrite函数向被调用程序发送数据。popen函数不支持任何其他选项。当popen启动的进程结束后,需要利用pclose关闭与之关联的文件流。如果在调用pclose时候,进程还在运行,那么pclose将会阻塞等待进程结束再返回。

    static void check_image(char * imagename)  
    {  
        FILE * fp;  
        char command[120];  
        char buf[200];  
        bool ret;  
      
        sprintf(command, "cksum %s", imagename);  
        fp = popen(command, "r");  
        if(fp == NULL) return;  
      
        fgets(buf, 200, fp);  
        fprintf(stdout, "Check Image:  %s... Done\n", buf);  
        fclose(fp);  
        return;  
    }  
    

    基于系统调用pipe的进程管道

    #include <unistd.h>  
    int pipe(int pipefd[2]);  
    

    利用pipe创建的管道包含两个文件描述符fd[0]以及fd[1],需要注意的是,该处是文件描述符而不是文件流,对该文件描述符进行读写必须采用read和write系统调用,管道的两端是固定了任务的。即一端只能用于读,由描述字fd[0]表示,称其为管道读端;另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。如果试图从管道写端读取数据,或者向管道读端写入数据都将导致错误发生。结构如下图:

    从管道中读取数据
    如果管道的写端不存在,则认为已经读到了数据的末尾,读函数返回的读出字节数为0;
    当管道的写端存在时,如果请求的字节数目大于PIPE_BUF,则返回管道中现有的数据字节数,如果请求的字节数目不大于PIPE_BUF,则返回管道中现有数据字节数(此时,管道中数据量小于请求的数据量);或者返回请求的字节数(此时,管道中数据量不小于请求的数据量)。

    向管道中写入数据
    向管道中写入数据时,linux将不保证写入的原子性,管道缓冲区一有空闲区域,写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据,那么写操作将一直阻塞。
    注:只有在管道的读端存在时,向管道中写入数据才有意义。否则,向管道中写入数据的进程将收到内核传来的SIFPIPE信号,应用程序可以处理该信号,也可以忽略(默认动作则是应用程序终止)。

    管道的主要局限性正体现在它的特点上:

    只支持单向数据流;
    只能用于具有亲缘关系的进程之间;
    没有名字;
    管道的缓冲区是有限的(管道制存在于内存中,在管道创建时,为缓冲区分配一个页面大小);
    管道所传送的是无格式字节流,这就要求管道的读出方和写入方必须事先约定好数据的格式,比如多少字节算作一个消息(或命令、或记录)等等;

    #include <stdio.h>  
    #include <stdlib.h>  
    #include <string.h>  
    #include <sys/types.h>  
    int main()  
    {  
        pid_t pid = 0;  
        int fds[2], nwr = 0;  
        char buf[128];  
        pipe(fds);  
        pid = fork();  
        if(pid < 0)  
        {   
            printf("Fork error.\n");  
            return -1;   
        }else if(pid == 0)  
        {   
            printf("This is child process, pid = %d\n", getpid());  
      
            //part A  
            printf("Child:waiting for message...\n");  
            nwr = read(fds[0], buf, sizeof(buf))  
            printf("Child:received\"%s\"\n", buf);   
      
            //part B  
            printf("Child:send reply\n");  
            strcpy(buf, "Reply from child");  
            nwr = write(fds[1], buf, sizeof(buf));   
            printf("Child:send %d bytes to parent.\n", nwr);  
      
        }else{  
            printf("This is parent process, pid = %d\n", getpid());  
      
            printf("Parent:sending message...\n");  
            strcpy(buf, "Message from parent");  
            nwr = write(fds[1], buf, sizeof(buf));  
            printf("Parent:send %d bytes to child.\n", nwr);  
      
            //part C  
            printf("Parent:waiting for reply from child...\n");  
            nwr = read(fds[0], buf, sizeof(buf));  
            printf("Parent:received \"%s\" from child\n", buf);  
        }  
        return 0;  
    }  
    

    命名管道

    管道应用的一个重大限制是它没有名字,因此,只能用于具有亲缘关系的进程间通信,在有名管道(named pipe或FIFO)提出后,该限制
    得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存在于文件系统中。这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信(能够访问该路径的进程以及FIFO的创建进程之间),因此,通过FIFO不相关的进程也能交换数据。值得注意的是,FIFO严格遵循先进先出(first in first out),对管道及FIFO的读总是从开始处返回数据,对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。

    对命名管道的操作和对文件操作相似,包括创建,打开,读写,和关闭操作。

    命名管道的创建

    #include <sys/types.h>  
    #include <sys/stat.h>  
      
    int mkfifo(const char *pathname, mode_t mode);  
    

    该函数的第一个参数是一个普通的路径名,也就是创建后FIFO的名字。第二个参数与打开普通文件的open()函数中的mode 参数相同。如果mkfifo的第一个参数是一个已经存在的路径名时,会返回EEXIST错误,所以一般典型的调用代码首先会检查是否返回该错误,如果确实
    返回该错误,那么只要调用打开FIFO的函数就可以了吗,程序如下:

    if(access(FIFO_NAME,F_OK)==-1){  
           res=mkfifo(FIFO_NAME,0777);  
           if(res!=0){  
                   fprintf(stderr,"Could not create fifo %s\n",FIFO_NAME);
                   exit(EXIT_FAILURE);  
          }  
    }  
    res=open(FIFO_NAME,open_mode);  
    

    命名管道的打开

    打开的FIFO的限制是:由于FIFO是单向数据传输,程序不能以O_RDWR方式打开FIFO同时进行读写操作,只能是O_RDONLY或者O_WRONLY方式,打开函数如下:

    #include <sys/types.h>  
    #include <sys/stat.h>  
    #include <fcntl.h>    
    int open(const char *pathname, int flags);  
    

    打开FIFO文件和普通文件的另外一个差别是:O_NONBLOCK选项对open的阻塞的影响,主要分为下面几种情况:

    • flags=O_RDONLY:open将会调用阻塞,除非有另外一个进程以写的方式打开同一个FIFO,否则一直等待。

    • flags=O_WRONLY:open将会调用阻塞,除非有另外一个进程以读的方式打开同一个FIFO,否则一直等待。

    • flags=O_RDONLY|O_NONBLOCK:如果此时没有其他进程以写的方式打开FIFO,此时open也会成功返回,此时FIFO被读打开,而不会返回错误

    • flags=O_WRONLY|O_NONBLOCK:立即返回,如果此时没有其他进程以读的方式打开,open会失败打开,此时FIFO没有被打开,返回-1。

    命名管道创建和打开测试程序:

    #include<unistd.h>  
    #include<stdlib.h>  
    #include<stdio.h>  
    #include<string.h>  
    #include<fcntl.h>  
    #include<sys/types.h>  
    #include<sys/stat.h>  
      
    #define FIFO_NAME "/tmp/my_fifo"  
      
    int main(int argc,char *argv[])  
    {  
            int res;  
            int open_mode=0;  
            if(argc < 2){  
                    fprintf(stderr,"Usage:%s<some combination of \  
                            O_RDONLY,O_WRONLY,O_NONBLOCK\n",*argv);  
                    exit(EXIT_FAILURE);  
            }  
            argv++;  
            if(strncmp(*argv,"O_RDONLY",8)==0)open_mode|=O_RDONLY;  
            if(strncmp(*argv,"O_WRONLY",8)==0)open_mode|=O_WRONLY;  
            if(strncmp(*argv,"O_NONBLOCK",10)==0)open_mode|=O_NONBLOCK;  
            argv++;  
            if(*argv){  
                    if(strncmp(*argv,"O_RDONLY",8)==0)open_mode|=O_RDONLY;  
                    if(strncmp(*argv,"O_WRONLY",8)==0)open_mode|=O_WRONLY;  
                    if(strncmp(*argv,"O_NONBLOCK",10)==0)open_mode|=O_NONBLOCK;  
            }  
            if(access(FIFO_NAME,F_OK)==-1){  
                    res=mkfifo(FIFO_NAME,0777);  
                    if(res!=0){  
                            fprintf(stderr,"Could not create fifo %s\n",FIFO_NAME);  
                            exit(EXIT_FAILURE);  
                    }  
            }  
            printf("process %d open FIFO with %d\n",getpid(),open_mode);  
            res=open(FIFO_NAME,open_mode);  
            printf("process %d result %d\n",getpid(),res);  
            sleep(5);  
            if(res!=-1)close(res);  
            printf("process %d finished\n",getpid());  
            exit(EXIT_SUCCESS);  
    }  
    
    命名管道的读写

    对命名管道的读写需要利用系统调用read函数:

    #include <unistd.h>  
      
    ssize_t read(int fd, void *buf, size_t count);  
    ssize_t write(int fd, const void *buf, size_t count);  
    
    读取管道

    是否采用O_NONBLOCK非阻塞标志对管道的读有影响:
    对一个空的,阻塞的FIFO文件的read调用将会等待,直到有数据可以读时才继续执行。
    对一个空的,非阻塞的FIFO的read系统调用将会立即返回0字节。

    写管道

    需要考虑FIFO可以存在的数据长度是有限制的,在limits.h文件中由#definde PIPE_BUF语句定义,通常是4096字节。
    对于设置了阻塞标志的写操作
    当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数,则进入睡眠,直到当缓冲区中能够容纳要写入的字节数时,才开始进行一次性写操作。
    当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域,写进程就会试图向管道写入数据,写操作在写完所有请求写的数据后返回。

    对于没有设置阻塞标志的写操作
    当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后,写操作返回。
    当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数,写完后成功返回;如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数,则返回EAGAIN错误,提醒以后再写;

    命名管道的关闭
    #include <unistd.h>  
    int close(int fd);  
    

    总结

    管道常用于两个方面:在shell中时常会用到管道(作为输入输入的重定向),在这种应用方式下,管道的创建对于用户来说是透明的;用于具有亲缘关系的进程间通信,用户自己创建管道,并完成读写操作。FIFO可以说是管道的推广,克服了管道无名字的限制,使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。管道和FIFO的数据是字节流,应用程序之间必须事先确定特定的传输"协议",采用传播具有特定意义的消息

    相关文章

      网友评论

        本文标题:管道机制

        本文链接:https://www.haomeiwen.com/subject/uzqmxttx.html