Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1594943
  • 博文数量: 249
  • 博客积分: 1305
  • 博客等级: 军士长
  • 技术积分: 4703
  • 用 户 组: 普通用户
  • 注册时间: 2011-12-17 10:37
个人简介

不懂的东西还有很多,随着不断的学习,不懂的东西更多,无法消灭更多不懂的东西,那就不断的充实自己吧。 欢迎关注微信公众号:菜鸟的机器学习

文章分类

全部博文(249)

文章存档

2015年(1)

2014年(4)

2013年(209)

2012年(34)

2011年(1)

分类: C/C++

2012-10-28 19:45:42

   最近,需要完成统计squid相关信息的代码,采用的是管道方式,基本完成了所需要的功能。众所周知,管道是进程间通信最古老的一种方式。
   为了更加一步的了解进程间通信,于是从网上找到一篇文章,讲的非常仔细,所以,摘录过来,以备后用,多学点知识。

   首先,进程间通信至少可以通过传送打开文件来实现,不同的进程通过一个或多个文件来传递信息,事实上,在很多应用系统里,都使用了这种方法。但一般说来, 进程间通信(IPC:InterProcess Communication)不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多,而且不幸的是,极少方法能在所有的Unix系 统中进行移植(唯一一种是半双工的管道,这也是最原始的一种通信方式)。而Linux作为一种新兴的操作系统,几乎支持所有的Unix下常用的进程间通信 方法:管道消息队列共享内存信号量套接口等等。下面我们将逐一介绍。 

一、管道

     管道是进程间通信中最古老的方式,它包括 无名管道  有名管道两种,前者用于父进程和子进程间的通信,后者用于运行于同一台机器上的任意两个进程间的通信
    无名管道由pipe()函数创建。
  1. #include <unistd.h>

  2. int pipe(int files[2]);

  3.                返回值:若成功则返回0,若出错则返回-1
   经由参数files返回两个文件描述符:files[0]为读而打开,files[1]为写而打开。files[1]的输出是files[0]的输入。

   下面的例子示范了如何在父进程和子进程间实现通信。

  1. #include <stdio.h> 
  2. #include <unistd.h>
  3.  
  4. #define INPUT 0
  5. #define OUTPUT 1
  6.  
  7. int main()
  8. {
  9.     int files[2];
  10.     pid_t pid;
  11.     char buf[256];
  12.     int returned_count;
  13.     
  14.     //创建无名管道
  15.     pipe(files);
  16.  
  17.     //创建子进程
  18.     
  19.     if((pid = fork()) == -1) 
  20.     { 
  21.         perror("fork() error");
  22.         return -1; 
  23.     } 
  24.  
  25.     //执行子进程
  26.     if(pid == 0)
  27.     { 
  28.         printf("in child process....\n");
  29.  
  30.         //子进程向父进程写数据,关闭管道的读端
  31.         close(files[INPUT]);
  32.         write(files[OUTPUT],"test data", strlen("test data"));
  33.      
  34.         exit(0);
  35.     } 
  36.     else
  37.     { 
  38.         //执行父进程
  39.         printf("in the parent process...\n");
  40.         //父进程从管道中读取子进程写的数据,关闭管道的写端
  41.         close(files[OUTPUT]);
  42.  
  43.         returned_count = read(files[0], buf, sizeof(buf));
  44.         buf[returned_count] = '\0';
  45.         printf("%d bytes of data receiced from spawned process:%s\n", returned_count, buf);
  46.     } 
  47.     
  48.     return 0;
  49. }
   运行结果如下所示。


   在Linux系统下,有名管道可以由两种方式创建:命令行方式mknod系统调用函数mkfifo。下面的两种途径都在当前目录下生成一个名为myfifo的有名管道。
  1. 方式一:mkfifo("myfifo","rw");
  2. 方式二:mknod myfifo p
   
   生成了有名管道,就可以使用一般的文件I/O函数,如open、close、read、write等来对它进行操作。
   下面是一个简单的例子,假设我们已经创建了一个名为myfifo的有名管道。
  1. //进程一:读有名管道

  2. #include <stdio.h>
  3. #include <unistd.h>
  4.         
  5. int main()
  6. { 
  7.     FILE * in_file;
  8.     int count = 1;
  9.     char buf[80];
  10.     in_file = fopen("myfifo", "r");
  11.     if(in_file == NULL)
  12.     { 
  13.         perror("fopen() error");
  14.         return -1; 
  15.     } 
  16.     while((count = fread(buf, 1, 80, in_file)) > 0) 
  17.     { 
  18.         printf("received from pipe:%s\n", buf);
  19.         fclose(in_file);
  20.     } 
  21.         
  22.     return 0;
  23. }
  1. //进程二:写有名管道

  2. #include <stdio.h>
  3. #include <unistd.h>
  4.              
  5. int main() 
  6. { 
  7.     FILE *out_file;
  8.     int count = 1;
  9.              
  10.     char buf[80];
  11.     out_file = fopen("myfifo","w");
  12.     if(out_file == NULL)
  13.     { 
  14.         perror("fopen() error");
  15.         return -1; 
  16.     } 
  17.              
  18.     sprintf(buf,"this is test data for the named pipe example/n"); 
  19.     fwrite(buf, 1, 80, out_file); 
  20.     fclose(out_file); 
  21.              
  22.     return 0; 
  23. } 

   
二、消息队列

   消息队列用于运行于同一台机器上的进程间通信,它和管道很相似,是一个在系统内核中用来保存消息的队列,它在系统内核中是以消息链表的形式出现。消息链表中节点的结构用msg声明。

   事实上,它是一种正逐步被淘汰的通信方式,我们可以用流管道或者套接口的方式来取代它。所以,我们对此方法也不再解释,也建议读者忽略这种方式。

三、共享内存

    共享内存是运行在同一台机器上的进程间通信最快的方式,因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区,其余进程对这块内存区进行读写。得到共享内存有两种方式:映射/dev/mem设备内存映像文件前一种方式不给系统带来额外的开销,但在现实中并不常用,因为它控制存取的将是实际的物理内存,在Linux系统下,这只有通过限制Linux系统存取的内存才可以做到,这当然不太实际。常用的方式是通过shmXXX函数族来实现利 用共享内存进行存储的。
    使用共享内存时要掌握的唯一诀窍是多个进程之间对一定存储区d同步访问。若服务器进程正在将数据放入共享内存,则在它做完这一操作之前,客户进程不应当去读取这些数据。
    通常,信号量是用来实现对共享内存访问的同步(记录锁也可以用于这种场合)。
  
    内核为每个共享存储段设置了一个shmid_ds结构。

    若要获得一个共享存储标识符,调用的第一个函数通常是shmget。
  1. #include <sys/shm.h>

  2. int shmget(key_t key, size_t size, int flag);
  3.  

  4.                    返回值:若成功则返回共享内存ID,若出错则返回-1
  5. 参数size:该共享存储段的长度(单位:字节)
     
    shmctl函数对共享存储段执行多种操作。
  1. #include <sys/shm.h>

  2. int shmctl(int shmid, int cmd, struct shmid_ds *buf);

  3.              返回值:若成功则返回0,若出错则返回-1
    
    一旦创建了共享存储段,进程就可调用shmat函数将其连接到它的地址空间中。
  1. #include <sys/shm.h>

  2. void shmat(int shmid, const void *addr, int flag);

  3.              返回值:若成功则返回共享存储的指针,若出错则返回-1
  4. 参数:shmid为shmget函数返回的共享内存标志符,addr和flag参数决定了以什么方式来确定连接的地址,函数的返回值即使该进程数据段所连接的实际地址,进程可对此进程进行读写操作。

     使用共享存储来实现进程间通信的注意点是对数据存取的同步,必须确保当一个进程去读取数据时,它所想要的数据已经写好了。通常,信号量被要来实现对共享存 储数据存取的同步,另外,可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。 

   
三、信号量

    信号量又称为信号灯,它是用来协调不同进程间的数据对象的,而最主要的应用是前一节的共享内存方式的进程间通信。本质上,信号量是一个计数器,它用来记录对某个资源(如共享内存)的存取状况。一般说来,为了获得共享资源,进程需要执行下列操作: 
   (1) 测试控制该资源的信号量。 
   (2) 若此信号量的值为正,则允许进行使用该资源。进程将信号量减1。 
   (3) 若此信号量为0,则该资源目前不可用,进程进入睡眠状态,直至信号量值大于0,进程被唤醒,转入步骤(1)。 
   (4) 当进程不再使用一个信号量控制的资源时,信号量值加1。如果此时有进程正在睡眠等待此信号量,则唤醒此进程。 
   维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文件/usr/src/linux/include /linux /sem.h 中看到内核用来维护信号量状态的各个结构的定义。信号量是一个数据集合,用户可以单独使用这一集合的每个元素。要调用的第一个函数是semget,用以获得一个信号量ID。 
  1. struct sem {
  2.   short sempid;/* pid of last operaton */
  3.   ushort semval;/* current value */
  4.   ushort semncnt;/* num procs awaiting increase in semval */
  5.   ushort semzcnt;/* num procs awaiting semval = 0 */
  6. }

  7. #include <sys/types.h>
  8. #include <sys/ipc.h>
  9. #include <sys/sem.h>

  10. int semget(key_t key, int nsems, int flag);
  11. 参数:
  12.     key是前面讲过的IPC结构的关键字;
  13.     flag将用来决定是创建新的信号量集合,还是引用一个现有的信号量集合;
  14.     nsems是该集合中的信号量数目;
  15. 如果创建新的集合(一般是在服务器中),则必须指定nsems;如果是引用一个现有的信号量集合(一般在客户机中),则将nsems指定为0.
     semctl函数用来对信号量进行操作。
  1. int semctl(int semid, int semnum, int cmd, union semun arg);

  2. 不同的操作是通过cmd参数来实现的,在头文件sem.h中定义了7种不同的操作,实际编程时可参考。
    semop函数自动执行信号量集合上的操作函数。
  1. int semop(int semid, struct sembuf semoparray[], size_t nops);
  2.    
  3. semoparray是一个指针,它指向一个信号量操作数组。nops规定该数组中操作的数量。
    下面,我们看一个具体的例子,它创建一个特定的IPC结构的关键字和一个信号量,建立此信号量的索引,修改索引指向的信号量的值,最后我们清除信号量。在下面的代码中,函数ftok生成我们上文所说的唯一的IPC关键字。 

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/sem.h>
  4. #include <sys/ipc.h>
  5.  
  6.  /* union semun is defined by including <sys/sem.h> */
  7.  /* according to X/OPEN we have to define it ourselves */
  8. union semun 
  9. {
  10.    int val; /* value for SETVAL */
  11.    struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
  12.    unsigned short *array; /* array for GETALL, SETALL */
  13.    /* Linux specific part: */
  14.    struct seminfo *__buf; /* buffer for IPC_INFO */
  15.  };
  16.  
  17. int main()
  18. {
  19.     key_t unique_key; /* 定义一个IPC关键字*/
  20.     int id;
  21.     struct sembuf lock_it;
  22.     union semun options;
  23.     int i;
  24.  
  25.     unique_key = ftok(".", 'a'); /* 生成关键字,字符'a'是一个随机种子*/
  26.     /* 创建一个新的信号量集合*/
  27.     id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);
  28.     printf("semaphore id=%d\n", id);
  29.     options.val = 1; /*设置变量值*/
  30.     semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/
  31.  
  32.     /*打印出信号量的值*/
  33.     i = semctl(id, 0, GETVAL, 0);
  34.     printf("value of semaphore at index 0 is %d\n", i);
  35.  
  36.     /*下面重新设置信号量*/
  37.     lock_it.sem_num = 0; /*设置哪个信号量*/
  38.     lock_it.sem_op = -1; /*定义操作*/
  39.     lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/
  40.     if (semop(id, &lock_it, 1) == -1) {
  41.         printf("can not lock semaphore.\n");
  42.         exit(1);
  43.     }
  44.  
  45.     i = semctl(id, 0, GETVAL, 0);
  46.     printf("value of semaphore at index 0 is %d\n", i);
  47.  
  48.     /*清除信号量*/
  49.     semctl(id, 0, IPC_RMID, 0);
  50.  
  51.     return 0;
  52.  }

四、信号量相关函数

4.1 semget

    可以使用系统调用semget()创建一个新的信号量集合,或者存取一个已经存在的信号量集合。
系统调用:semget();
原型:intsemget(key_t key,int nsems,int semflg);
返回值:如果成功,则返回信号量集的IPC标识符。如果失败,则返回-1:errno=EACCESS(没有权限)
EEXIST(信号量集已经存在,无法创建)
EIDRM(信号量集已经删除)
ENOENT(信号量集不存在,同时没有使用IPC_CREAT)
ENOMEM(没有足够的内存创建新的信号量集)
ENOSPC(超出限制)

         系统调用semget()的第一个参数是关键字值(一般是由系统调用ftok()返回的)。系统内核将此值和系统中存在的其他的信号量集的关键字值进行比较。打开和存取操作与参数semflg中的内容相关。IPC_CREAT如果信号量集在系统内核中不存在,则创建信号量集。IPC_EXCL当和 IPC_CREAT一同使用时,如果信号量集已经存在,则调用失败。如果单独使用IPC_CREAT,则semget()要么返回新创建的信号量集的标识符,要么返回系统中已经存在的同样的关键字值的信号量的标识符。如果IPC_EXCL和IPC_CREAT一同使用,则要么返回新创建的信号量集的标识符,要么返回-1。IPC_EXCL单独使用没有意义。参数nsems指出了一个新的信号量集中应该创建的信号量的个数。
       信号量集中最多的信号量的个数是在linux/sem.h中定义的。
  1. #define SEMMSL 32 //最大信号量数目
    
4.2 semop

系统调用:semop();
调用原型:int semop(int semid,struct sembuf*sops,unsign ednsops);
返回值:0,如果成功。-1,如果失败:errno=E2BIG(nsops大于最大的ops数目)
EACCESS(权限不够)
EAGAIN(使用了IPC_NOWAIT,但操作不能继续进行)
EFAULT(sops指向的地址无效)
EIDRM(信号量集已经删除)
EINTR(当睡眠时接收到其他信号)
EINVAL(信号量集不存在,或者semid无效)
ENOMEM(使用了SEM_UNDO,但无足够的内存创建所需的数据结构)
ERANGE(信号量值超出范围)

    第一个参数是关键字值。第二个参数是指向将要操作的数组的指针。第三个参数是数组中的操作的个数。参数sops指向由sembuf组成的数组。此数组是在linux/sem.h中定义的。

五、套接口

    套接口(socket)编程是实现Linux系统和其他大多数操作系统中进程间通信的主要方式之一。我们熟悉的WWW服务、FTP服务等都是基于套接口编程来实现的。除了异地的计算机进程间外,套接口同样适用于本地同一台计算机内部的进程间通信。
       关于这部分,可以参照《设计自己的网络蚂蚁》,链接为:。那里由常用的几个套接口函数的介绍和示例程序。这一部分或许是Linux进程 间通信编程中最须关注和最吸引人的一部分,毕竟,Internet 正在我们身边以不可思议的速度发展着,如果一个程序员在设计编写他下一个程序的时候,根本没有考虑到网络,考虑到Internet,那么,可以说,他的设计很难成功。



      
      主要是对进程间通信的相关知识进行了总结,更加深入的理解,还是要到实践中去。
      
      本文主要参考了《UNIX环境高级编程》和文章http://blog.csdn.net/eroswang/article/details/1772350


梦醒潇湘love
                                              2012/10/28 20:31
阅读(4362) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册