Linux进程通信总结(二) --管道

原创 于 2012-04-20 16:37:18 发布 · 670 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #服务器 #server #buffer #数据结构 #gcc

本文详细介绍了Linux中的管道与FIFO的概念、特点以及如何使用它们进行进程间通信。通过两个实验案例，展示了如何使用FIFO实现进程间数据的单向与双向传递，并分析了其效率。最后，介绍了如何使用FIFO实现客户/服务器应用程序，以及在实验过程中观察到的性能表现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

    管道是Linux中很重要的一种通信方式,是把一个程序的输出直接连接到另一个程序的输入,常说的管道多是指无名管道,无名管道只能用于具有亲缘关系的进程之间，这是它与有名管道的最大区别。 
    有名管道叫named pipe或者FIFO(先进先出)，可以用函数mkfifo()创建。 

    从本质上说，管道也是一种文件,但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：
    1)限制管道的大小。

        实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节，使得它的大小不象文件那样不加检验地增长。使 用单个固定缓冲区也会带来问题，比如在写管道时可能变满，当这种情况发生时，随后对管道的write()调用将默认地被阻塞，等待某些数据被读取，以便腾 出足够的空间供write()调用写。 
·   2)读取进程也可能工作得比写进程快。

       当所有当前进程数据已被读取时，管道变空。当这种情况发生时，一个随后的read()调用将默认地被阻塞，等待某些数据被写入，这解决了read()调用返回文件结束的问题。

    3)从管道读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多的数据。

       在 Linux 中，管道的实现并没有使用专门的数据结构，而是借助了文件系统的file结构和VFS的索引节点inode。通过将两个 file 结构指向同一个临时的 VFS 索引节点，而这个 VFS 索引节点又指向一个物理页面而实现的。 

创建一个管道：

#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而言是非常有效率的。

一、实验：使用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);   
}   

//消费者程序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);   
}   



编译这两个程序：


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


user 0m0.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;    


      
接下来是服务器程序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);   
}   





      
客户端程序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);   
}  




编译程序：




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调用处以等待客户的到来，就像它最初启动时那样。




 






 


                

        

    

    
  



    



            

  



          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值