管道（无名管道）通信机制原理和实现详解

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

在实现管道时，应该考虑以下四个问题：

1. 管道允许单向通信还是双向通信？
2. 如果允许双向通信，它是半双工的（数据在同一时间内只能按一个方向传输）还是全双工的（数据在同一时间内可在两个方向上传输）？
3. 通信进程之间是否应有一定的关系（如父子关系）？
4. 管道通信能否通过网络，还是只能在同一台机器上进行？

无名管道（普通管道）

pipe (int 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;
}

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",TRUE,/* inherit handles */
    0，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;
}

#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;
}

（编辑：ASP站长网）