Chinaunix首页 | 论坛 | 博客
  • 博客访问: 7894466
  • 博文数量: 701
  • 博客积分: 2150
  • 博客等级: 上尉
  • 技术积分: 13233
  • 用 户 组: 普通用户
  • 注册时间: 2011-06-29 16:28
个人简介

天行健,君子以自强不息!

文章分类

全部博文(701)

文章存档

2019年(2)

2018年(12)

2017年(76)

2016年(120)

2015年(178)

2014年(129)

2013年(123)

2012年(61)

分类: LINUX

2012-11-15 10:43:55

1. Linux进程间的通信简介
Linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。
AT&T的贝尔实验室和BSD(加州大学伯克利分校的伯克利软件发布中心)
Unix发展做出重大贡献,
但是他们在进程间通信方面的侧重点有所不同。

前者对Unix早期的进程间通信手段进行了系统的改进和扩充,
形成了“system V IPC”,但是通信进程局限在单个计算机内;

后者则跳过了单个计算机内限制,形成了基于套接口(socket)的进程间通信机制。
Linux则把两者继承了下来。

如下图所示:
2. 管道
管道是Linux支持的最初Unix IPC形式之一,具有以下特点:
  A. 管道是半双工的,数据只能向一个方向流动;
  B. 需要双工通信时,需要建立起两个管道;
  C. 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程)
  D. 单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,
     但它不是普通的文件,它不属于某种文件系统,而是自立门户,
     单独构成一种文件系统,并且只存在与内存中。

数据的读出和写入:
一个进程向管道中写的内容被管道另一端的进程读出。
写入的内容每次都添加在管道缓冲区的末尾,
并且每次都是从缓冲区的头部读出数据。

匿名管道的创建:

  1. #include <unistd.h>
  2. int pipe(int fd[2]);
该函数创建的管道的两端处于一个进程中间,在实际应用中没有太大意义;
因此,一个进程在由pipe()创建管道后,一般再fork一个子进程,
然后通过管道实现父子进程间的通信。
因此只要两个进程中存在亲缘关系(这里的亲缘关系指的是具有共同的祖先),
都可以采用管道方式来进行通信

3.匿名管道的读写规则:
管道两端可分别用描述字fd[0]以及fd[1]来描述,
需要注意的是,管道的两端是固定了任务的。
即一端只能用于读,由描述字 fd[0]表示,称其为管道读端;
另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。
如果试图从管道写端读取数据,
或者向管道读端写入数据 都将导致错误发生。
一般文件的I/O函数都可以用于管道,如closereadwrite等等。

从管道中读取数据:
  如果管道的写端不存在,则认为已经读到了数据的末尾,读函数返回的读出字节数为0
  当管道的写端存在时,
    如果请求的字节数目大于PIPE_BUF,        则返回管道中现有数据字节数.

4.示例
很多书本或是参考资料讲解进程间通信的例子,
通常都只是一个父进程与子进程间的实现,对于实用的启发性不大,

本例是我自己写的一个实现:
生成了两个子进程:转换进程和写进程;
实现了读取文件,转换成大写,并写输出文件的功能。

父进程不断读文件的数据并通过匿名管道发送到转换进程;
转换进程从匿名管道读取数据,转换后,通过匿名管道发送到写进程;
写进程从匿名管道读取数据并写到文件。

下面是流程图:

这样的设计是对多进程并行工作的模拟,
可以使得读取,转码,写进程实现流水线般的并行,
稍作改进,添加功能后,能用在很多的场合。

以下是代码实现:
main.c

  1. /*
  2.  * \File
  3.  *   main.c
  4.  * \Descript
  5.  *   father-process reads input file and sends to child-process by anonymous-pipe
  6.  *   client-process transform and write into output file
  7.  */

  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <sys/types.h>
  11. #include <sys/stat.h>
  12. #include <fcntl.h>
  13. #include <unistd.h>

  14. #include "trans.h"

  15. FILE* fp_in = NULL;
  16. FILE* fp_out = NULL;
  17. #define TESTF_IN "test.dat"
  18. #define TESTF_OUT "out.dat"
  19. #define MAX_LINE 512
  20. #define OP_LEN 100
  21. /*
  22.  * \Func
  23.  * main
  24.  * \Descript
  25.  *
  26.  */
  27. int main(char argc, char* argv[])
  28. {
  29.   int pidstatus;
  30.   int fdfile_in, fdfile_out;

  31.   int fdpipe_a[2];
  32.   int fdpipe_b[2];
  33.   int pid_trans = -1, pid_write = -1;


  34.   /* Create anonymous-pipe */
  35.   if( (pipe(fdpipe_a) < 0) || (pipe(fdpipe_b) < 0))
  36.   {
  37.     printf("open pipe failed.\n");
  38.     exit(1);
  39.   }

  40.   if ( (fp_in = fopen(TESTF_IN, "r")) < 0 )
  41.   {
  42.     printf("open input file failed: %s\n", TESTF_IN);
  43.     exit(1);
  44.   }

  45.   if ( (fp_out = fopen(TESTF_OUT, "w")) < 0 )
  46.   {
  47.     printf("open input file failed: %s\n", TESTF_OUT);
  48.     exit(1);
  49.   }

  50.   if ( (pid_trans = fork()) && (pid_write = fork()) )    
  51.   {
  52.     /*
  53.      * PARENT_PROCESS:
  54.      * read data from in-file, write it into anonymos-pipe.
  55.      */

  56.      int s_read = 0, s_write;
  57.      char bufparent[512];    

  58.      while((s_read = fread(bufparent, sizeof(char), OP_LEN ,fp_in) ) )
  59.      {
  60.        printf("***** %d, %s\n", s_read, bufparent);
  61.        if ( (s_write = write(fdpipe_a[1], bufparent, s_read)) < 0 )
  62.        {
  63.          printf("write pipe failed.\n");
  64.          exit(1);
  65.        }
  66.        memset(bufparent, 0, 512);
  67.        if( feof(fp_in) != 0 )
  68.        {
  69.          printf("\n***** OVER ******\n");
  70.          exit(1);
  71.        }
  72.      }
  73.   }
  74.   else if ( pid_trans == 0 )
  75.   {
  76.     /*
  77.      * TRANS_PROCESS:
  78.      * read anonymous-pipe, transcode, write anonymos-pipe.
  79.      */

  80.     char buftrans_in[512], buftrans_out[512];
  81.     int size_read, size_write;
  82.     int ret;

  83.     while(size_read = read(fdpipe_a[0], buftrans_in, OP_LEN))
  84.     {
  85.       ret = trans_lower2upper(buftrans_in, buftrans_out, size_read);

  86.       if ( (size_write = write(fdpipe_b[1], buftrans_out, size_read)) < 0 )
  87.       {
  88.         printf("trans-process write failed.\n");
  89.         exit(2);
  90.        }
  91.     }
  92.   }
  93.   else if ( pid_write == 0 )
  94.   {
  95.     /*
  96.      * WRITE_PROCESS:
  97.      * read anonymous-pipe, write it into out-file
  98.      */
  99.     int s_read, s_write;
  100.     char bufwrite[512];

  101.     while ( s_read = read(fdpipe_b[0], bufwrite, OP_LEN) )
  102.     {
  103.       if( (s_write = fwrite(bufwrite, sizeof(char), s_read, fp_out)) < 0)
  104.       {
  105.         printf("..... write error.\n");
  106.         exit(3);
  107.       }
  108.       if(s_read < OP_LEN)
  109.       {
  110.         break;
  111.       }
  112.     }
  113.   }
  114.   else
  115.   {
  116.       printf("fork process failed.\n");
  117.       exit(1);
  118.   }

  119.   waitpid(pid_trans, &pidstatus, 0);
  120.   waitpid(pid_write, &pidstatus, 0);
  121.   fclose(fp_out);
  122.   fclose(fp_in);
  123.   return 0;
  124. }

trans.h

  1. /*
  2.  * \File
  3.  * trans.h
  4.  * \Descript
  5.  *
  6.  */
  7.     
  8. #ifndef __TRANS_H__
  9. #define __TRANS_H__
  10.                                                                                           
  11. int trans_lower2upper(char* buf_in, char* buf_out, int len);
  12.       
  13. #endif

trans.c

  1. /*
  2.  * \File
  3.  * trans.c
  4.  * \Descript
  5.  *
  6.  */
  7.     
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10.     
  11. #include "trans.h"
  12.                                                                                        
  13. /*
  14.  * \Func
  15.  * trans_lower2upper
  16.  * \Descript
  17.  * Lowercase turn uppercase
  18.  */
  19. int trans_lower2upper(char* buf_in, char* buf_out, int buf_len)
  20. {
  21.   int len = buf_len;
  22.   char* cp_in = buf_in;
  23.   char* cp_out = buf_out;
  24.   char atom;
  25.   char offset;

  26.   while(len--)
  27.   {
  28.     atom = *(cp_in++);
  29.     
  30.     if( (atom >= 'a') && (atom <= 'z') )
  31.     {
  32.       offset = atom - 'a';
  33.       atom = 'A' + offset;
  34.     }
  35.     *(cp_out++) = atom;
  36.   }

  37.   return 0;
  38. }

makefile

  1. OBJECTS = main.o trans.o
  2. CC = gcc

  3. anonymous_pipe : $(OBJECTS)
  4.   $(CC) -o anonymous_pipe $(OBJECTS)

  5. main.o:trans.h
  6. trans.o:trans.h

  7. .PHONY:clean
  8. clean:
  9.   rm anonymous_pipe $(OBJECTS)
测试通过;
阅读(6128) | 评论(0) | 转发(2) |
给主人留下些什么吧!~~