管道和FIFO

1. 管道（pipe）

      管道在Unix及Linux進程間通信是最基礎的，很容易理解。管道就像一個自來水管，一端注入水，一端放出水，水只能在一個方向上流動，而不能雙向流動。管道是典型的單向通信，即計算機網絡中所說的“半雙工”。管道又名匿名管道，所以只能用在具有公共祖先的進程之間使用，通常使用在父子進程之間通信。通常是父進程創建一個管道，然后fork一個子進程，此后父子進程共享這個管道進行通信。

　　管道由pipe函數創建，函數原型如下：

      #include<unistd.h>

      int　　pipe(int fd[2]); 成功返回0，否則返回-1；參數fd返回兩個文件描述符，fd[0]為讀，fd[1]為寫，fd[1]的輸入是fd[0]的輸出。即fd[0]對應讀端，fd[1]對應寫端。

      舉例說明一下管道的用法：模擬client-server通信過程，父進程模擬client，子進程模擬server。server向client發送一個字符串，client接收到輸出到屏幕。

　　

 1 #include <unistd.h>
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 #include <sys/types.h>
 5 #include <errno.h>
 6 #include <string.h>
 7 
 8 int main()
 9 {
10     int fd[2];
11     pid_t childpid;
12     char buf[100];
13 
14     memset(buf,0,100);
15     //創建一個管道
16     if(pipe(fd) == -1)
17     {
18         perror("pipe() error");
19         exit(-1);
20     }
21     //創建一個子進程
22     childpid = fork();
23     if(childpid == 0)
24     {
25         printf("server input a message : ");
26         scanf("%s",buf);
27         //關閉讀端
28         close(fd[0]);
29         write(fd[1],buf,strlen(buf));
30         exit(0);
31     }
32     if(childpid == -1)
33     {
34         perror("fork() error");
35         exit(-1);
36     }
37     //父進程關閉寫端
38     close(fd[1]);
39     read(fd[0],buf,100);
40     printf("client read a message: %s\n",buf);
41     waitpid(childpid,NULL,0);
42     return 0;
43 }

 

程序執行結果如下：

上面程序的細節問題在於子進程需要關閉讀端，父進程需要關閉寫端。因為管道最早提出時候是單向，雖然現在有些系統提供全雙工的管道。那么如何采用管道實現雙向通信呢？很顯然我們需要兩個管道，控制兩個不同的數據流向。現在有模擬一個Client和Server雙向通信的過程，Client與Server之間可以相互發送和接收信息。此時需要兩個管道進行模擬，管道1模擬Server寫Client讀數據流向，管道2模擬Client寫Server讀數據流向。代碼如下所示：

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

int main()
{
    int fd1[2],fd2[2];
    pid_t childpid;
    char buf[100];

    memset(buf,0,100);
    
    if(pipe(fd1) == -1)
    {
        perror("pipe() error");
        exit(-1);
    }
    if(pipe(fd2) == -1)
    {
        perror("pipe() error");
        exit(-1);
    }
    childpid = fork();
    if(childpid == 0)
    {
        printf("Server input a message : ");
        gets(buf);
        close(fd1[0]);
        close(fd2[1]);
        write(fd1[1],buf,strlen(buf));
        read(fd2[0],buf,100);
        printf("Server received message from client:%s\n",buf);
        exit(0);
    }
    if(childpid == -1)
    {
        perror("fork() error");
        exit(-1);
    }
    close(fd1[1]);
    close(fd2[0]);
    read(fd1[0],buf,100);
    printf("Client receive a message from server: %s\n",buf);
    printf("Client input a message : ");
    gets(buf);
    write(fd2[1],buf,strlen(buf));
    waitpid(childpid,NULL,0);
    return 0;
}

程序執行結果如下：

　　2 FIFO(first in first out)

　　FIFO又名有名管道，相對於上述管道而言。管道沒有名字，因此只能在具有共同祖先進程的各個進程之間通信，無法在無親緣關系的兩個進程之間創建一個管道進行通信。為此有了FIFO，類似管道，也是一個單向（半雙工）數據流，每個FIFO有一個路徑名與之關聯，從而允許無親緣關系的進程訪問同一個FIFO。FIFO有mkfifo函數創建。

#include <sys/types.h>

#include <sys/stat.h>

int mkfifo(const char *pathname,mode_t mode); 成功返回0，出錯返回-1。pathname是一個普通的路徑名，是FIFO的名字，mode指定文件的權位。

在創建FIFO后，必須打開來讀或者打開來寫，不能打開來既讀既寫（因為FIFO是半雙工）。現在采用FIFO實現上面的第二個例子，代碼如下：

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

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

#define FIFO1   "/tmp/fifo.1"
#define FIFO2   "/tmp/fifo.2"

int main()
{
    int readfd,writefd;
    pid_t   childpid;
    char buf[100];
    memset(buf,0,100);
    //創建FIFO
    if((mkfifo(FIFO1,FILE_MODE) < 0) && (errno != EEXIST))
    {
        perror("mkfifo() error");
        exit(-1);
    }
    if((mkfifo(FIFO2,FILE_MODE) < 0) && (errno != EEXIST))
    {
        unlink(FIFO1);
        perror("mkfifo() error");
        exit(-1);
    }
     //創建子進程
    childpid = fork();
    if(childpid == 0)
    {
        readfd = open(FIFO1,O_RDONLY,0);
        writefd = open(FIFO2,O_WRONLY,0);
        printf("Server input a message: ");
        gets(buf);
        write(writefd,buf,strlen(buf));
        read(readfd,buf,100);
        printf("Server received a message from Client: %s\n",buf);
        exit(0);
    }
    if(childpid == -1)
    {
        perror("frok() error");
        exit(-1);
    }
     //防止死鎖，注意順序
    writefd = open(FIFO1,O_WRONLY,0);
    readfd = open(FIFO2,O_RDONLY,0);
    read(readfd,buf,100);
    printf("Client received a message form Server: %s\n",buf);
    printf("Client input a mesage: ");
    gets(buf);
    write(writefd,buf,strlen(buf));
    waitpid(childpid,NULL,0);
    close(readfd);
    close(writefd);
    unlink(FIFO1);
    unlink(FIFO2);
    return 0;
}

運行結果如下：

 上面的程序當中父進程打開FIFO的順序不能顛倒，否則會造成死鎖。因為在當前沒有任何進程打開某個FIFO來寫的時候，打開該FIFO來讀的進程將會阻塞。交換父進程中兩個open的調用順序后，父子進程都將打開同一個FIFO進行讀，而當前沒有任何進程來打開該文件進行寫，於是父子進程都阻塞，造成死鎖。

下面采用FIFO實現無親緣關系的兩個進程之間的通信。Client與Server是兩個獨立的進程。

//公共同文件fifo.h
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

#define FIFO1   "/tmp/fifo.1"
#define FIFO2   "/tmp/fifo.2"

//server進程 server.c 
#include "fifo.h"

int main()
{
    int readfd,writefd;
    pid_t   childpid;
    char buf[100];
    memset(buf,0,100);
    //創建FIFO
    if((mkfifo(FIFO1,FILE_MODE) < 0) && (errno != EEXIST))
    {
        perror("mkfifo() error");
        exit(-1);
    }
    if((mkfifo(FIFO2,FILE_MODE) < 0) && (errno != EEXIST))
    {
        unlink(FIFO1);
        perror("mkfifo() error");
        exit(-1);
    }
    readfd = open(FIFO1,O_RDONLY,0);
    writefd = open(FIFO2,O_WRONLY,0);
    printf("Server input a message: ");
    gets(buf);
    write(writefd,buf,strlen(buf));
    read(readfd,buf,100);
    printf("Server received a message from Client: %s\n",buf);
    return 0;
}

//client進程 client。c
#include "fifo.h"

int main()
{
    int readfd,writefd;
    pid_t   childpid;
    char buf[100];
    memset(buf,0,100);
    //創建FIFO
    if((mkfifo(FIFO1,FILE_MODE) < 0) && (errno != EEXIST))
    {
        perror("mkfifo() error");
        exit(-1);
    }
    if((mkfifo(FIFO2,FILE_MODE) < 0) && (errno != EEXIST))
    {
        unlink(FIFO1);
        perror("mkfifo() error");
        exit(-1);
    }

     //防止死鎖，注意順序
    writefd = open(FIFO1,O_WRONLY,0);
    readfd = open(FIFO2,O_RDONLY,0);
    read(readfd,buf,100);
    printf("Client received a message form Server: %s\n",buf);
    printf("Client input a mesage: ");
    gets(buf);
    write(writefd,buf,strlen(buf));
    close(readfd);
    close(writefd);
    unlink(FIFO1);
    unlink(FIFO2);
    return 0;
}

先執行server進程，然后執行client進程：結果如下：

以上介紹了管道和FIFO的操作方法。

參考資料：

《Unix環境高級編程》