首页 > 编程笔记 > 操作系统笔记 阅读:1,674

管道(无名管道)通信机制原理和实现详解

管道(pipe)允许两个进程进行通信,是早期 UNIX 系统最早使用的一种 IPC 机制。管道为进程之间的相互通信提供了一种较为简单的方法,尽管也有一定的局限性。

在实现管道时,应该考虑以下四个问题:
  1. 管道允许单向通信还是双向通信?
  2. 如果允许双向通信,它是半双工的(数据在同一时间内只能按一个方向传输)还是全双工的(数据在同一时间内可在两个方向上传输)?
  3. 通信进程之间是否应有一定的关系(如父子关系)?
  4. 管道通信能否通过网络,还是只能在同一台机器上进行?

有两种常见类型的用于 UNIX 和 Windows 系统的管道:无名管道(普通管道)有名管道,本节先讲解无名管道。

无名管道(普通管道)

普通管道允许两个进程按标准的生产者-消费者方式进行通信:生产者向管道的一端(写入端)写,消费者从管道的另一端(读出端)读。

因此,普通管道是单向的,只允许单向通信。如果需要双向通信,那么就要采用两个管道,而每个管道向不同方向发送数据。

下面我们讨论在 UNIX 和 Windows 系统上创建普通管道。在这两个程序实例中,一个进程向管道中写入消息 Greetings,而另一个进程从管道中读取此消息。

在 UNIX 系统上,普通管道的创建采用函数

pipe (int fd[])

这个函数创建一个管道,以便通过文件描述符 int fd[] 来访问:fd[0] 为管道的读出端,而 fd[1] 为管道的写入端。UNIX 将管道作为一种特殊类型的文件。因此,访问管道可以采用普通的系统调用 read() 和 write()。

普通管道只能由创建进程所访问。通常情况下,父进程创建一个管道,并使用它来与其子进程进行通信(该子进程由 fork() 来创建)。正如《进程的创建》一节所讲的那样,子进程继承了父进程的打开文件。由于管道是一种特殊类型的文件,因此子进程也继承了父进程的管道。


图 1 普通管道的文件描述符

图 1 说明了文件描述符 fd 与父子进程之间的关系。
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#define BUFFER_SIZE 25
#define READ_END 0
#define WRITE_END 1

int main(void)
{
    char write_msg[BUFFER_SIZE] = "Greetings";
    char read_msg[BUFFER_SIZE];
    int fd[2];
    pid_t pid;
    /* create the pipe */
    if (pipe(fd) == -1) {
        fprintf(stderr,"Pipe failed");
        return 1;
    }
    /* fork a child process */
    pid = fork();
    if (pid < 0) {
        /* error occurred */
        fprintf(stderr, "Fork Failed");
        return 1;
    }
    if (pid > 0) {
        /* parent process */
        /* close tlie unused end of the pipe */
        close (fd [READJEND]);
       
        /* write to the pipe */
        write (fd [WRITE_END],write_msg, strlen (write_msg)+1);
        /* close the read end of the pipe */
        close (fd[WRITE_END]);
    }
    else {
        /* child process */
        /* close the unused end of the pipe */
        close(fd[WRITEJEND]);
        /* read from the pipe */
        read(fd[READ_END] , read_msg, BUFFER_SIZE);
        printf ("read %s",read_msg);
        /* close the write end of the pipe */
        close (fd[READ_END]);
    }
    return 0;
}
上边的 UNIX 程序中,父进程创建了一个管道,然后调用 fork() 来创建子进程。调用 fork() 之后的行为取决于数据流如何流过管道。

对于这个实例,父进程向管道写,而子进程从管道读。重要的是要注意,父进程和子进程开始就关闭了管道的未使用端。有一个重要的步骤是确保当管道的写入者关闭了管道写入端时,从管道读取的进程能检测到 end-of-file(调用 read() 返回 0),不过上边所示的程序中没有这个操作。

对于 Windows 系统,普通管道被称为匿名管道(anonymous pipe),它们的行为类似于 UNIX 的管道:它们是单向的,通信进程之间具有父子关系。

另外,读取和写入管道可以采用普通函数 ReadFile() 和 WriteFile()。用于创建管道的 Windows API 是 CreatePipe() 函数,它有四个参数,包括:
  1. 读取管道的句柄;
  2. 写入管道的句柄;
  3. STARTUPINFO结构的一个实例,用于指定子进程继承管道的句柄;
  4. 可以指定管道的大小(以字节为单位);

下面的代码说明了一个父进程创建一个匿名管道,以便与子进程通信:
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define BUFFER_SIZE 25
int main(VOID)
{
    HANDLE ReadHandle, WriteHandle;
    STARTUPINFO si;
    PR0CESS_INF0RMATI0N pi;
    char message [BUFFER_SIZE] = "Greetings";
    DWORD written;
    /* set up security attributes allowing pipes to be inherited */
    SECURITY_ATTRIBUTES sa = {sizeof (SECURITY_ATTRIBUTES) ,NULL,TRUE};
    /* allocate memory */
    ZeroMemory(&pi,sizeof(pi));
    /* create the pipe */
    if (!CreatePipe(&ReadHandle, &WriteHandle, &sa, 0)) {
        fprintf(stderr, "Create Pipe Failed");
        return 1;
    }
    /* establish the STARTJNFO structure for the child process */
    GetStartupInfo(&si);
    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    /* redirect standard input to the read end of the pipe */
    si.hStdlnput = ReadHandle;\
    si.dwFlags = STARTF.USESTDHANDLES;
    /* don5t allow the child to inherit the write end of pipe */
    SetHandlelnformat ion (WriteHandle, HANDLEJFLAGJNHERIT, 0);
    /* create the child process */
    CreateProcess (NULL, "child.exe" , NULL, NULL,TRUE, /* inherit handles */
    0,NULL, NULL, &si, &pi);
    /* close the unused end of the pipe */
    CloseHandle(ReadHandle);
    /* the parent writes to the pipe */
    if (! WriteFile (WriteHandle, message,BUFFER.SIZE,&written,NULL))
        fprintf(stderr, "Error writing to pipe.");
    /* close the write end of the pipe */
    CloseHandle(WriteHandle);
    /* wait for the child to exit */
    WaitForSingleObject(pi.hProcess, INFINITE);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    return 0;
}
对于 UNIX 系统,子进程自动继承由父进程创建的管道;对于 Windows 系统,程序员需要指定子进程继承的属性。首先,初始化结构 SECURITY_ATTRIBUTES,以便允许句柄继承;然后,重定向子进程的句柄,以便标准输入或输出为管道的读出或写入。由于子进程从管道上读,父进程应将子进程的标准输入重定向为管道的读出句柄。另外,由于管道为半双工,需要禁止子进程继承管道的写入端。

创建子进程的程序中,第五个参数设置为 TRUE,表示子进程会从父进程那里继承指定的句柄。父进程向管道写入时,应先关闭未使用的管道读出端。从管道读的子进程如下所示:
#include <stdio.h>
#include <windows.h>
#define BUFFER_SIZE 25
int main (VOID)
{
    HANDLE Readhandle;
    CHAR buffer [BUFFER_SIZE];
    DWORD read;
    /* get the read handle of the pipe */
    ReadHandle = GetStdHandle (STDJNPUTJHANDLE);
    /* the child reads from the pipe */
    if (ReadFile(ReadHandle, buffer, BUFFER_SIZE, &read, NULL))
        printf ("child read %s",buffer);
    else
        fprintf(stderr, "Error reading from pipe");
    return 0;
}
从管道读之前,这个程序应通过调用 GetStdHandle(),以得到管道的读句柄。

请注意,对于 UNIX 和 Windows 系统,采用普通管道的进程通信需要有父子关系。这 意味着,这些管道只可用于同一机器的进程间通信。

所有教程

优秀文章