Linux进程通信：命名管道FIFO小结

Linux进程通信：命名管道FIFO小结

转载自：http://blog.csdn.net/MONKEY_D_MENG/article/details/5651430#

 

      Linux下进程之间通信可以用命名管道FIFO完成。命名管道是一种特殊类型的文件，因为Linux中所有事物都是文件，它在文件系统中以文件名的形式存在。

在程序中，我们可以使用两个不同的函数调用来建立管道：

#include <sys/types.h>

#include <sys/stat.h>

 

int mkfifo(const char *filename, mode_t mode);

int mknode(const char *filename, mode_t mode | S_IFIFO, (dev_t) 0 );

 

下面先来创建一个管道：

 

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>

int main()
{
    int res = mkfifo("/tmp/my_fifo", 0777);
    if (res == 0)
    {
        printf("FIFO created/n");
    }
    exit(EXIT_SUCCESS);
}

#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> int main() { int res = mkfifo("/tmp/my_fifo", 0777); if (res == 0) { printf("FIFO created/n"); } exit(EXIT_SUCCESS); }

编译这个程序：

gcc –o fifo1.c fifo

 

运行这个程序：

$ ./fifo1

 

用ls命令查看所创建的管道

$ ls -lF /tmp/my_fifo

prwxr-xr-x 1 root root 0 05-08 20:10 /tmp/my_fifo|

注意：ls命令的输出结果中的第一个字符为p，表示这是一个管道。最后的|符号是由ls命令的-F选项添加的，它也表示是这是一个管道。

虽然，我们所设置的文件创建模式为“0777”，但它被用户掩码（umask）设置（022）给改变了，这与普通文件创建是一样的，所以文件的最终模式为755。

打开FIFO一个主要的限制是，程序不能是O_RDWR模式打开FIFO文件进行读写操作，这样做的后果未明确定义。这个限制是有道理的，因为我们使用FIFO只是为了单身传递数据，所以没有必要使用O_RDWR模式。如果一个管道以读/写方式打开FIFO，进程就会从这个管道读回它自己的输出。如果确实需要在程序之间双向传递数据，最好使用一对FIFO，一个方向使用一个。

当一个Linux进程被阻塞时，它并不消耗CPU资源，这种进程的同步方式对CPU而言是非常有效率的。

有关Linux下命名管道FIFO的读写规则可以参见之前所写的一篇文章：Linux命名管道FIFO的读写规则。

 

 

亲缘关系进程间的FIFO通信

/*
 * 有亲缘关系的进程间的fifo的使用
 * fifo 使用的简单例子
 */

#include "../all.h"

#define FIFO_PATH "/tmp/hover_fifo"


void 
do_sig(int signo)
{
    if (signo == SIGCHLD)
        while (waitpid(-1, NULL, WNOHANG) > 0)
            ;
}



int
main(void)
{
    int ret;
    int fdr, fdw;
    pid_t pid;

    char words[10] = "123456789";
    char buf[10] = {'\0'};    
    
    // 创建它,若存在则不算是错误,
    // 若想修改其属性需要先打开得到fd,然后用fcntl来获取属性,然后设置属性.

    if (((ret = mkfifo(FIFO_PATH, FILE_MODE)) == -1) 


                     && (errno != EEXIST))
        perr_exit("mkfifo()");
    fprintf(stderr, "fifo : %s created successfully!\n", FIFO_PATH);

    signal(SIGCHLD, do_sig);

    pid = fork();
    if (pid == 0) { // child

        if ((fdr = open(FIFO_PATH, O_WRONLY)) < 0) // 打开fifo用来写
            perr_exit("open()");
        sleep(2);

        // 写入数据
        if (write(fdr, words, sizeof(words)) != sizeof(words)) 
            perr_exit("write");
        fprintf(stderr, "child write : %s\n", words);
        close(fdw);
    } else if (pid > 0) { // parent

        if ((fdr = open(FIFO_PATH, O_RDONLY)) < 0) // 打开fifo用来读

            perr_exit("open()");

        fprintf(stderr, "I father read, waiting for child ...\n");
        if (read(fdr, buf, 9) != 9) //读数据
            perr_exit("read");

        fprintf(stderr, "father get buf : %s\n", buf);
        close(fdr);
    }
    // 到这里fifo管道并没有被删除,必须手动调用函数unlink或remove删除.

    return 0;    
}

 从例子上可以看出使用fifo时需要注意:
*fifo管道是先调用mkfifo创建,然后再用open打开得到fd来使用.
*在打开fifo时要注意,它是半双工的的,一般不能使用O_RDWR打开,而只能用只读或只写打开

 

一、实验：使用FIFO实现进程间通信

两个独立的程序：

1.     生产者程序，它在需要时创建管道，然后尽可能快地向管道中写入数据。

2.     消费者程序，它从FIFO中读取数据并丢弃它们。

 

生产者程序fifo2.c：

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

#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
#define TEN_MEG (1024 * 1024 * 10)

int main()
{
    int pipe_fd;
    int res;
    int open_mode = O_WRONLY;

    int bytes = 0;
    char buffer[BUFFER_SIZE + 1];

    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 opening FIFO O_WRONLY/n", getpid());
    pipe_fd = open(FIFO_NAME, open_mode);
    printf("Process %d result %d/n", getpid(), pipe_fd);

    if (pipe_fd != -1)
    {
        while (bytes < TEN_MEG)
        {
            res = write(pipe_fd, buffer, BUFFER_SIZE);
            if (res == -1)
            {
                fprintf(stderr, "Write error on pipe/n");
                exit(EXIT_FAILURE);
            }
            bytes += res;
        }
        close(pipe_fd);
    }
    else
    {
        exit(EXIT_FAILURE);
    }

    printf("Process %d finish/n", getpid());
    exit(EXIT_SUCCESS);
}

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h> #include <limits.h> #include <sys/types.h> #include <sys/stat.h> #define FIFO_NAME "/tmp/Linux/my_fifo" #define BUFFER_SIZE PIPE_BUF #define TEN_MEG (1024 * 1024 * 10) int main() { int pipe_fd; int res; int open_mode = O_WRONLY; int bytes = 0; char buffer[BUFFER_SIZE + 1]; 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 opening FIFO O_WRONLY/n", getpid()); pipe_fd = open(FIFO_NAME, open_mode); printf("Process %d result %d/n", getpid(), pipe_fd); if (pipe_fd != -1) { while (bytes < TEN_MEG) { res = write(pipe_fd, buffer, BUFFER_SIZE); if (res == -1) { fprintf(stderr, "Write error on pipe/n"); exit(EXIT_FAILURE); } bytes += res; } close(pipe_fd); } else { exit(EXIT_FAILURE); } printf("Process %d finish/n", getpid()); exit(EXIT_SUCCESS); }

 

消费者程序fifo3.c：

 

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

#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF

int main()
{
    int pipe_fd;
    int res;

    int open_mode = O_RDONLY;
    char buffer[BUFFER_SIZE + 1];
    int bytes = 0;

    memset(buffer, '/0', sizeof(buffer));

    printf("Process %d opeining FIFO O_RDONLY/n", getpid());
    pipe_fd = open(FIFO_NAME, open_mode);
    printf("Process %d result %d/n", getpid(), pipe_fd);

    if (pipe_fd != -1)
    {
        do{
            res = read(pipe_fd, buffer, BUFFER_SIZE);
            bytes += res;
        }while(res > 0);
        close(pipe_fd);
    }
    else
    {
        exit(EXIT_FAILURE);
    }

    printf("Process %d finished, %d bytes read/n", getpid(), bytes);
    exit(EXIT_SUCCESS);
}

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h> #include <limits.h> #include <sys/types.h> #include <sys/stat.h> #define FIFO_NAME "/tmp/Linux/my_fifo" #define BUFFER_SIZE PIPE_BUF int main() { int pipe_fd; int res; int open_mode = O_RDONLY; char buffer[BUFFER_SIZE + 1]; int bytes = 0; memset(buffer, '/0', sizeof(buffer)); printf("Process %d opeining FIFO O_RDONLY/n", getpid()); pipe_fd = open(FIFO_NAME, open_mode); printf("Process %d result %d/n", getpid(), pipe_fd); if (pipe_fd != -1) { do{ res = read(pipe_fd, buffer, BUFFER_SIZE); bytes += res; }while(res > 0); close(pipe_fd); } else { exit(EXIT_FAILURE); } printf("Process %d finished, %d bytes read/n", getpid(), bytes); exit(EXIT_SUCCESS); }

编译这两个程序：

gcc –o fifo2 fifo2.c

gcc –o fifo3 fifo3.c

 

运行这两个程序：

[root@localhost chaper12]# ./fifo2 &     à后台执行，写数据

[2] 23121

Process 23121 opening FIFO O_WRONLY

[root@localhost chaper12]# time ./fifo3à读数据

Process 24155 opeining FIFO O_RDONLY

Process 23121 result 3

Process 24155 result 3

Process 23121 finish

Process 24155 finished, 10485760 bytes read

[2]- Done                   ./fifo2

 

real 0m0.214s

user0m0.000s

sys 0m0.179s

 

以上两个程序均是使用阻塞模式FIFO。Linux会安排好这两个进程之间的调试，使它们在可以运行的时候运行，在不能运行的时候阻塞。因此，写进程将在管道满时阻塞，读进程将在管道空时阻塞。

虚拟机上，time命令显示，读进程只运行了0.2秒的时间，却读取了10M字节的数据。这说明管道在程序之间传递数据是非常有效的。

 

二、实验：使用FIFO的客户/服务器应用程序

      利用FIFO实现一个客户/服务器的应用程序，服务器进程接受请求，对它们进程处理，最后把结果数据返回给发送请求的客户方。

      首先建立一个头文件client.h，它定义了客户和服务器程序都要用到的数据结构，并包含了必要的头文件。

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

#define SERVER_FIFO_NAME "/tmp/Linux/chaper12/server_fifo"
#define CLIENT_FIFO_NAME "/tmp/Linux/chaper12/client_%d_fifo"

#define BUFFER_SIZE PIPE_BUF
#define MESSAGE_SIZE 20
#define NAME_SIZE 256

typedef struct message
{
    pid_t client_pid;
    char data[MESSAGE_SIZE + 1];
}message;

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h> #include <limits.h> #include <sys/types.h> #include <sys/stat.h> #define SERVER_FIFO_NAME "/tmp/Linux/chaper12/server_fifo" #define CLIENT_FIFO_NAME "/tmp/Linux/chaper12/client_%d_fifo" #define BUFFER_SIZE PIPE_BUF #define MESSAGE_SIZE 20 #define NAME_SIZE 256 typedef struct message { pid_t client_pid; char data[MESSAGE_SIZE + 1]; }message;

 

      接下来是服务器程序server.c，在这一部分，是以只读阻塞模式打开服务器管道，用于接收客户发送过来的数据，这些数据采用message结构体封装。

#include "client.h"

int main()
{
    int server_fifo_fd;
    int client_fifo_fd;

    int res;
    char client_fifo_name[NAME_SIZE];

    message msg;

    char *p;

    if (mkfifo(SERVER_FIFO_NAME, 0777) == -1)
    {
        fprintf(stderr, "Sorry, create server fifo failure!/n");
        exit(EXIT_FAILURE);
    }

    server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
    if (server_fifo_fd == -1)
    {
        fprintf(stderr, "Sorry, server fifo open failure!/n");
        exit(EXIT_FAILURE);
    }

    sleep(5);

   while (res = read(server_fifo_fd, &msg, sizeof(msg)) > 0)
   {
        p = msg.data;
        while (*p)
        {
        *p = toupper(*p);
        ++p;
        }

        sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
        client_fifo_fd = open(client_fifo_name, O_WRONLY);
        if (client_fifo_fd == -1)
        {
        fprintf(stderr, "Sorry, client fifo open failure!/n");
        exit(EXIT_FAILURE);
        }

        write(client_fifo_fd, &msg, sizeof(msg));
        close(client_fifo_fd);
    }

    close(server_fifo_fd);
    unlink(SERVER_FIFO_NAME);
    exit(EXIT_SUCCESS);
}

#include "client.h" int main() { int server_fifo_fd; int client_fifo_fd; int res; char client_fifo_name[NAME_SIZE]; message msg; char *p; if (mkfifo(SERVER_FIFO_NAME, 0777) == -1) { fprintf(stderr, "Sorry, create server fifo failure!/n"); exit(EXIT_FAILURE); } server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY); if (server_fifo_fd == -1) { fprintf(stderr, "Sorry, server fifo open failure!/n"); exit(EXIT_FAILURE); } sleep(5); while (res = read(server_fifo_fd, &msg, sizeof(msg)) > 0) { p = msg.data; while (*p) { *p = toupper(*p); ++p; } sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid); client_fifo_fd = open(client_fifo_name, O_WRONLY); if (client_fifo_fd == -1) { fprintf(stderr, "Sorry, client fifo open failure!/n"); exit(EXIT_FAILURE); } write(client_fifo_fd, &msg, sizeof(msg)); close(client_fifo_fd); } close(server_fifo_fd); unlink(SERVER_FIFO_NAME); exit(EXIT_SUCCESS); }

      客户端程序client.c，这个程序用于向服务器发送消息，并接收来自服务器的回复。

 

#include "client.h"

int main()
{
    int server_fifo_fd;
    int client_fifo_fd;

    int res;

    char client_fifo_name[NAME_SIZE];

    message msg;

    msg.client_pid = getpid();
    sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);

    if (mkfifo(client_fifo_name, 0777) == -1)
    {
        fprintf(stderr, "Sorry, create client fifo failure!/n");
        exit(EXIT_FAILURE);
    }

    server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY);
    if (server_fifo_fd == -1)
    {
        fprintf(stderr, "Sorry, open server fifo failure!/n");
        exit(EXIT_FAILURE);
    }

    sprintf(msg.data, "Hello from %d", msg.client_pid);
    printf("%d sent %s ", msg.client_pid, msg.data);
    write(server_fifo_fd, &msg, sizeof(msg));

    client_fifo_fd = open(client_fifo_name, O_RDONLY);
    if (client_fifo_fd == -1)
    {
        fprintf(stderr, "Sorry, client fifo open failure!/n");
        exit(EXIT_FAILURE);
    }
    res = read(client_fifo_fd, &msg, sizeof(msg));
    if (res > 0)
    {
        printf("received:%s/n", msg.data);
    }

    close(client_fifo_fd);
    close(server_fifo_fd);
    unlink(client_fifo_name);

    exit(EXIT_SUCCESS);
}

#include "client.h" int main() { int server_fifo_fd; int client_fifo_fd; int res; char client_fifo_name[NAME_SIZE]; message msg; msg.client_pid = getpid(); sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid); if (mkfifo(client_fifo_name, 0777) == -1) { fprintf(stderr, "Sorry, create client fifo failure!/n"); exit(EXIT_FAILURE); } server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY); if (server_fifo_fd == -1) { fprintf(stderr, "Sorry, open server fifo failure!/n"); exit(EXIT_FAILURE); } sprintf(msg.data, "Hello from %d", msg.client_pid); printf("%d sent %s ", msg.client_pid, msg.data); write(server_fifo_fd, &msg, sizeof(msg)); client_fifo_fd = open(client_fifo_name, O_RDONLY); if (client_fifo_fd == -1) { fprintf(stderr, "Sorry, client fifo open failure!/n"); exit(EXIT_FAILURE); } res = read(client_fifo_fd, &msg, sizeof(msg)); if (res > 0) { printf("received:%s/n", msg.data); } close(client_fifo_fd); close(server_fifo_fd); unlink(client_fifo_name); exit(EXIT_SUCCESS); }

编译程序：

gcc –o server server.c

gcc –o client client.c

 

测试这个程序，我们需要一个服务器进程和多个客户进程。为了让多个客户进程在同一时间启动，我们使用了shell命令：

[root@localhost chaper12]# ./server &

[26] 5171

[root@localhost chaper12]# for i in 1 2 3 4 5; do ./client & done

[27] 5172

[28] 5173

[29] 5174

[30] 5175

[31] 5176

[root@localhost chaper12]# 5172 sent Hello from 5172 received:HELLO FROM 5172

5173 sent Hello from 5173 received:HELLO FROM 5173

5174 sent Hello from 5174 received:HELLO FROM 5174

5175 sent Hello from 5175 received:HELLO FROM 5175

5176 sent Hello from 5176 received:HELLO FROM 5176

 

      分析这个例子，服务器以只读模式创建它的FIFO并阻塞，直到第一个客户以写方式打开同一现个FIFO来建立连接为止。此时，服务器进程解除阻塞并执行sleep语句，这使得来自客户的数据排除等候。在实际应用程序中，应该把sleep语句删除，这里面只是为了演示当有多个客户请求同时到达时，程序的正确操作方法。

      与此同时，在客户端打开服务器FIFO后，它创建自己唯一的一个命名管道以读取服务器返回的数据。完成这些工作后，客户发送数据给服务器（如果管道满或服务器仍处于休眠就阻塞），并阻塞于对自己FIFO的read调用上，等待服务器响应。

      接收到来自客户的数据后，服务器处于它，然后以写的方式打开客户管道并将处理后的数据返回，这将解除客户端的阻塞状态，客户程序就可以从自己的管道里面读取服务器返回的数据了。

      整个处理过程不断重复，直到最后一个客户关闭服务器管道为止，这将使服务器的read调用失败（返回0），因为已经没有进程以写方式打开服务器管道了。如果这是一个真正的服务器进程的话，它还需要继续等待其他客户的请求，我们就需要对它进行修改，有两种方法：

      （1）对它自己的服务器管道打开一个文件描述符，这样read调用将阻塞而不是返回0。

      （2）当read调用返回0时，关闭并重新打开服务器管道，使服务器进程阻塞在open调用处以等待客户的到来，就像它最初启动时那样。