进程间通信-管道

Linux下进程间通信概述

  • Linux下的进程通信手段基本上是从UNIX平台上的进程通信手段继承而来的。而对UNIX发展做出重大贡献的两大主力AT&T的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间的通信方面的侧重点有所不同。前者是对UNIX早期的进程间通信手段进行了系统的改进和扩充，形成了“system V IPC”，其通信进程主要局限在单个计算机内；后者则跳过了该限制，形成了基于套接口（socket）的进程间通信机制。而Linux则把两者的优势都继承了下来

  • UNIX进程间通信（IPC）方式包括管道、FIFO以及信号。
    System V进程间通信（IPC）包括System V消息队列、System V信号量以及System V共享内存区。
    Posix 进程间通信（IPC）包括Posix消息队列、Posix信号量以及Posix共享内存区。


进程间通信方式的种类

  • 管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信；有名管道，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。
  • 信号（Signal）：信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一样的。
  • 消息队列（Messge Queue）：消息队列是消息的链接表，包括Posix消息队列、SystemV消息队列。它克服了前两种通信方式中信息量有限的缺点，具有写权限的进程可以按照一定的规则向消息队列中添加新消息；对消息队列有读权限的进程则可以从消息队列中读取消息。
  • 共享内存（Shared memory）：可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据的更新。这种通信方式需要依靠某种同步机制，如互斥锁和信号量等。
  • 信号量（Semaphore）：主要作为进程之间以及同一进程的不同线程之间的同步和互斥手段。
  • 套接字（Socket）：这是一种更为一般的进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。

管道

  • 无名管道是Linux中进程间通信的一种方式。
    它只能用于具有亲缘关系的进程之间的通信（也就是父子进程或者兄弟进程之间）。
    它是一个半双工的通信模式，具有固定的读端和写端。
    管道也可以看成是一种特殊的文件，对于它的读写也可以使用普通的read()和write()等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内核的内存空间中。


  • 管道是基于文件描述符的通信方式，当一个管道建立时，它会创建两个文件描述符fds[0]和fds[1]，其中fds[0]固定用于读管道，而fd[1]固定用于写管道，这样就构成了一个半双工的通道。
  • 创建管道可以通过调用pipe()来实现。

  • 管道关闭时只需使用普通的close()函数逐个关闭各个文件描述符。


父子进程之间的管道通信

  • 用pipe()函数创建的管道两端处于一个进程中，由于管道是主要用于在不同进程间通信的，因此这在实际应用中没有太大意义。实际上，通常先是创建一个管道，再通过fork()函数创建一子进程，该子进程会继承父进程所创建的管道 。



    父子进程分别拥有自己的读写通道，为了实现父子进程之间的读写，只需把无关的读端或写端的文件描述符关闭即可。此时，父子进程之间就建立起了一条“子进程写入父进程读取”的通道。


  • 代码实战：
    pipe.c
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<string.h>
#define BUFFER_SIZE 256

int main()
{
    int pipe_fd[2],real_read,real_write;
    pid_t pid;
    char buf[BUFFER_SIZE];
    char test_data[]="Hello,this pipe test!\n";
    
    memset((void*)buf,0,sizeof(buf));
    
    if(pipe(pipe_fd)==-1)
    {
        printf("pipe error!\n");
        return -1;
    }
    pid=fork();
    if(-1==pid)
    {
        printf("fork error!\n");
        return -1;
    }
    else if(0==pid)//In child process
    {
        close(pipe_fd[1]);
        sleep(3);//wait parent write
        
        if((real_read=read(pipe_fd[0],buf,BUFFER_SIZE))>0)
        {
            printf("In child process:\n%d bytes child read from pipe is %s\n",real_read,buf);
        }
        
        close(pipe_fd[0]);
        exit(0);
    }
    close(pipe_fd[0]);
    sleep(1);//wait child close pipe write fd
    if((real_write=write(pipe_fd[1],test_data,strlen(test_data)))!=-1)
    {
        printf("In parent process:\n%d bytes parent write to pipe is %s\n",real_write,test_data);
    }   
    close(pipe_fd[1]);
    wait();
    exit(0);
    return 0;
}

标准流管道

  • 与Linux的文件操作中所有基于文件流的标准I/O操作一样，管道的操作也支持基于文件流的模式。
  • 这种基于文件流的管道主要是用来创建一个连接到另一个进程的管道，这里的“另一个进程”也就是一个可以进行一定操作的可执行文件，例如，用户执行“ls -l”或者自己编写的程序“./pipe”等。由于这一类操作很常用，因此标准流管道就将一系列的创建过程合并到一个函数popen()中完成。
  • popen()包括有以下几步工作：
    创建一个管道。
    fork()一个子进程。
    在父子进程中关闭不需要的文件描述符。
    执行exec函数族调用。
    执行函数中所指定的命令。
  • 标准流管道的使用可以大大减少代码的编写量，但同时也有一些不利之处，例如，它不如前面管道创建的函数那样灵活多样，并且用popen()创建的管道必须使用标准I/O函数进行操作，不能使用前面的read()、write()一类不带缓冲的I/O函数。

  • 与之相对应，关闭用popen()创建的流管道必须使用函数pclose()来关闭该管道流。该函数关闭标准I/O流，并等待命令执行结束。



  • 标准流管道代码实战：
    popen.c
#include<stdio.h>
#include<stdlib.h>

#define BUFFER_SIZE 256

int main()
{
    FILE *fp;
    int num=0;
    char buf[BUFFER_SIZE];
    memset((void *)buf,0,sizeof(buf));
    //char cmd[]="./hello"
    fp=popen("./hello","r");//creat pipe link to hello 
     
    if(fp==NULL)
    {
        printf("popen error!\n");
        exit(0);
    }
    if((fread(buf,1,BUFFER_SIZE,fp))>0)//read data form pipe "fd"
    {       
        printf("From pipe read is: %s\n",buf);
    }
    

    pclose(fp);
    return 0;
}

有名管道

  • 前面介绍的管道是无名管道，它只能用于具有亲缘关系的进程之间，这就大大地限制了管道的使用。
  • 有名管道的出现突破了这种限制，它可以使互不相关的两个进程实现彼此通信。该管道可以通过路径名来指出，并且在文件系统中是可见的。在建立了管道之后，两个进程就可以把它当作普通文件一样进行读写操作，使用非常方便。
  • FIFO是严格地遵循先进先出规则的，对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾，它们不支持如lseek()等文件定位操作。
  • 有名管道的创建可以使用函数mkfifo()，该函数类似文件中的open()操作，可以指定管道的路径和打开的模式
  • 在创建管道成功之后，就可以使用open()、read()和write()这些函数了。与普通文件的打开设置一样，对于为读而打开的管道可在open()中设置O_RDONLY，对于为写而打开的管道可在open()中设置O_WRONLY，在这里与普通文件不同的是阻塞（进程是否挂起）问题。
  • 由于普通文件的读写时不会出现阻塞问题，而在管道的读写中却有阻塞的可能，这里的非阻塞标志可以在open()函数中设定为O_NONBLOCK。
  • 对于读进程
    若该管道是阻塞打开，且当前FIFO内没有数据，则对读进程而言将一直阻塞（挂起）到有数据写入。
    若该管道是非阻塞打开，则不论FIFO内是否有数据，读进程都会立即执行读操作。即如果FIFO内没有数据，则读函数将立刻返回0。

  • 对于写进程
    若该管道是阻塞打开，则写操作将一直阻塞到数据可以被写入。
    若该管道是非阻塞打开而不能写入全部数据，则读操作进行部分写入或者调用失败。


  • 代码实战：
    read.c
#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<errno.h>
#include<fcntl.h>
#include<limits.h>

#define MYFIFO "./myfifo"
#define BUFFER_SIZE PIPE_BUF   //It's defined in limits.h 

int main()
{
    int fd_myfifo;
    char buf[BUFFER_SIZE];
    
    //creat fifo
    if(access(MYFIFO,F_OK)==-1)//detect fifo is or not
    {
        if((mkfifo(MYFIFO, 0666)<0 )&& (errno != EEXIST))
        {
            printf("mkfifo error!\n");
            return -1;
        }
    }
    //open fifo,要已阻塞的方式读，要等有数据读操作才返回
   // fd_myfifo = open("./myfifo",O_RDONLY|O_NONBLOCK);
    fd_myfifo = open("./myfifo",O_RDONLY);
    if(fd_myfifo==-1)
    {
        printf("open myfifo error\n");
        return -1;
    }
    
    //receive words from write process
    printf("when received 'quit' to exit\n");
    do{
        memset((void *)buf,0,sizeof(buf));//clear buf to zero
        if(read(fd_myfifo,buf,BUFFER_SIZE)>0)
        {
            printf("In read process,received: %s\n",buf);
        }
    }while(strncmp(buf,"quit",4));
    printf("\n");
    close(fd_myfifo);
    return -1;
}

write.c

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

#define MYFIFO "./myfifo"
#define BUFFER_SIZE PIPE_BUF

int main(int argc,char **argv)
{
    int fd_myfifo;
    char buf[BUFFER_SIZE];
    memset((void *)buf,0,sizeof(buf));
    
    
    if(access(MYFIFO,F_OK)==-1)//detect fifo is or not exist
    {
        printf("Please create fifo in read process!\n");
        return -1;
    }
    //已阻塞方式写
    if((fd_myfifo=open(MYFIFO,O_WRONLY))==-1)
    {
        printf("write open myfifo error\n");
        return -1;
    }
    if(argc<=1)
    {
        printf("usage: ./write transfer_words\n");
    }
    //将命令行中字符串拷贝到buf
    strcpy(buf,argv[1]);
    
    if(write(fd_myfifo,buf,strlen(buf))>0)
    {
        printf("In write process,transfered: %s\n",buf);
    }
    close(fd_myfifo);
    return -1;
}
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • 进程间通信--管道通信
    进程间通信在两个进程之间，每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到。比如，在...
    basetree阅读 4,237评论 0赞 0
  • 进程间通信之管道
    前言 管道是UNIX环境中历史最悠久的进程间通信方式，也是最简单的进程间通信方式，一般用来作为IPC的入门，最合适...
    GeekerLou阅读 5,174评论 0赞 6
  • 进程相关（三）--进程间通信（管道）
    管道是一种用于在进程间共享数据的机制，其实质是一段共享内存。Windows系统为这段共享的内存设计采用数据流I/0...
    7bfedbe4863a阅读 4,260评论 0赞 0
  • 2020-08-27 Linux 的进程间通信：管道
    linux的管道是什么？ --pipe是一种跨进程通信的方式。分为匿名管道和命名管道。分别可以由“|”操作符和“m...
    魔王八斗阅读 1,882评论 0赞 0
  • 14.进程间通信：管道
    1. 管道，有名管道和无名管道。 1.1 无名管道主要用于父子进程或者兄弟关系的进程间的通信。通过pipe创建无名...
    陈忠俊阅读 1,432评论 0赞 0

友情链接更多精彩内容