2017-2018-1 20155320第十周课下作业-IPC

研究Linux下IPC机制：原理，优缺点，每种机制至少给一个示例，提交研究博客的链接

共享内存
管道
FIFO
信号
消息队列

共享内存

共享内存允许两个或更多进程访问同一块内存。当一个进程改变了这块内存中的内容的的时候，其他进程都会察觉到这个更改。

进程间需要共享的数据放入内核的共享内存区，进程可以把共享内存映射到自己进程的地址空间去，所以进程可以直接读取内存，不需要任何数据的拷贝。

共享内存原理

system V IPC机制下的共享内存本质是一段特殊的内存区域，进程间需要共享的数据被放在该共享内存区域中，所有需要访问该共享区域的进程都要把该共享区域映射到本进程的地址空间（虚拟地址空间）中去。这样一个使用共享内存的进程可以将信息写入该空间，而另一个使用共享内存的进程又可以通过简单的内存读操作获取刚才写入的信息，使得两个不同进程之间进行了一次信息交换，从而实现进程间的通信。共享内存允许一个或多个进程通过同时出现在它们的虚拟地址空间的内存进行通信，而这块虚拟内存的页面被每个共享进程的页表条目所引用，同时并不需要在所有进程的虚拟内存都有相同的地址。进程对象对于共享内存的访问通过key（键）来控制，同时通过key进行访问权限的检查。

实例(参考Linux-IPC之共享内存的实例)

以下为删除共享内存实例

#include <stdio.h>  
#include <sys/types.h>  
#include <sys/ipc.h>  
#include <stdlib.h>  
#include <sys/shm.h>  
#define PROJ_ID 1  
  
int main(int argc,char* argv[])  
{  
    if(argc!=2)  
    {  
        printf("error args
");  
        return -1;  
    }  
    key_t skey;  
    skey=ftok(argv[1],PROJ_ID);  
    if(-1==skey)  
    {  
        perror("ftok");  
        return -1;  
    }  
    printf("the key is %d
",skey);  
    int shmid;  
    shmid=shmget(skey,1<<12,0600|IPC_CREAT);  
    if(-1==shmid)  
    {  
        perror("shmget");  
        return -1;  
    }  
    printf("the shmid is %d
",shmid);  
    int ret;  
    if(-1==ret)  
    {  
        perror("shmctl_rmid");  
        return -1;  
    }  
    return 0;  
}

运行结果为

管道(PIPE)

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

管道特点

只支持单向数据流；
只能用于具有亲缘关系的进程之间；
没有名字；
管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

函数

管道的创建

#include <unistd.h>

int pipe(int fd[2]);

- 利用popen和pclose函数可以创建和关闭管道

fd为两个文件描述符：fd[0]用来读，fd[1]用来写。

1.父子进程的单向通信方式如下图：

一个进程创建一个管道——>派生一个自身的拷贝——>父进程关闭管道的读出端，子进程的写入端关闭（上图中的虚线）——>父子进程就建立了单向通信了。

父子进程的双向通信方式如下图：

实例

#include<stdio.h>
#include<unistd.h>
#include<string.h>
 
int main()
{
      int p[2];
      int pid;
      char *str = "HelloWorld";
      char buf[128];
      memset(buf,'',128);
 
      if(pipe(p) == -1)
      {
              printf("function pipe() calls failed.");
              return -1;
      }
 
      if((pid=fork()) == -1)  //创建一个子进程
      {
              printf("function fork() calls failed.
");
              return -1;
      }
      else if(pid == 0)  //在子进程中
      {
              printf("In sub : pid=%d
",getpid());
              write(p[1],str,strlen(str)); //向无名管道中写入str
      }else {  //在父进程中
              printf("In father : pid=%d
",getpid());
              read(p[0],buf,strlen(str));  //读取无名管道
              printf("In father : buf=%s
",buf);
      }
}

FIFO(有名管道)

FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间）

FIFO的应用

(1）在shell中时常会用到管道（作为输入输入的重定向），在这种应用方式下，管道的创建对于用户来说是透明的；

（2）用于具有亲缘关系的进程间通信，用户自己创建管道，并完成读写操作。

实例

#include <stdio.h>  
 
#include <stdlib.h>  
 
#include <string.h>  
 
#include <errno.h>  
 
#include <unistd.h>  
 
#include <sys/types.h>  
 
#include <sys/stat.h>  
 
#include <fcntl.h>  
  
  
  
/*在这里设置打开管道文件的mode为只读形式*/  
 
#define FIFOMODE (O_CREAT | O_RDWR | O_NONBLOCK)  
 
#define OPENMODE (O_RDONLY | O_NONBLOCK)  
 
#define FIFO_SERVER "myfifo"  
  
  
  
int main(void)  
  
{  
  
        char buf[100];  
  
        int fd;  
  
        int readnum;  
  
  
  
        /*创建有名管道，设置为可读写，无阻塞，如果不存在则按照指定权限创建*/  
  
        if ((mkfifo(FIFO_SERVER, FIFOMODE) < 0) && (errno != EEXIST)) {  
  
                printf("cannot create fifoserver/n");  
  
                exit(1);  
  
        }  
  
  
  
        printf("Preparing for reading bytes... .../n");  
  
  
  
        /*打开有名管道，并设置非阻塞标志*/  
  
        if ((fd = open(FIFO_SERVER, OPENMODE)) < 0) {  
  
                perror("open");  
  
                exit(1);  
  
        }  
  
  
  
        while (1) {  
  
                /*初始化缓冲区*/  
  
                bzero(buf, sizeof(buf));  
  
                /*读取管道数据*/  
  
                if ((readnum = read(fd, buf, sizeof(buf))) < 0) {  
  
                        if (errno == EAGAIN) {  
  
                                printf("no data yet/n");  
  
                        }  
  
                }  
  
                /*如果读到数据则打印出来，如果没有数据，则忽略*/  
  
                if (readnum != 0) {  
  
                        buf[readnum] = '/0';  
  
                        printf("read %s from FIFO_SERVER/n", buf);  
  
                }  
  
                sleep(1);  
  
        }  
  
  
  
        return 0;  
  
}

信号

信号量是进程/线程同步的一种方式，有时候我们需要保护一段代码，使它每次只能被一个执行进程/线程运行，这种工作就需要一个二进制开关；

有时候需要限制一段代码可以被多少个进程/线程执行，这就需要用到关于计数信号量。信号量开关是二进制信号量的一种逻辑扩展，两者实际调用的函数都是一样。

工作原理

由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：

P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行

V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1.

实例

// 加入信号量操作后的程序

#include "mysem.h"
#include <stdio.h>
#include <unistd.h>

int main()
{
    int semid = create_sems(10); // 创建一个包含10个信号量的信号集
    init_sems(semid, 0, 1);  // 初始化编号为 0 的信号量值为1

    pid_t id = fork(); // 创建子进程
    if( id < 0)
    {
        perror("fork");
        return -1;
    }
    else if (0 == id)
    {// child 
        int sem_id = get_sems();
        while(1)
        {
            P(sem_id, 0); // 对该信号量集中的0号信号  做P操作
            printf("你");
            fflush(stdout);
            sleep(1);
            printf("好");
            printf(":");
            fflush(stdout);
            sleep(1);
            V(sem_id, 0);
        }
    }
    else
    {// father
        while(1)
        {
            P(semid,0);
            printf("在");
            sleep(1);
            printf("吗");
            printf("?");
            fflush(stdout);
            V(semid, 0);
        }
        wait(NULL);
    }

    destroy_sems(semid);
    return 0;
}

消息队列

消息队列就是一个消息的链表。可以把消息看作一个记录，具有特定的格式以及特定的优先级。对消息队列有写权限的进程可以向其中按照一定的规则添加新消息；对消息队列有读权限的进程则可以从消息队列中读走消息

实例

消息发送端：send.c

 1 /*send.c*/  
 2 #include <stdio.h>   
 3 #include <sys/types.h>   
 4 #include <sys/ipc.h>   
 5 #include <sys/msg.h>   
 6 #include <errno.h>   
 7 
 8 #define MSGKEY 1024   
 9   
10 struct msgstru  
11 {  
12    long msgtype;  
13    char msgtext[2048];   
14 };  
15   
16 main()  
17 {  
18   struct msgstru msgs;  
19   int msg_type;  
20   char str[256];  
21   int ret_value;  
22   int msqid;  
23   
24   msqid=msgget(MSGKEY,IPC_EXCL);  /*检查消息队列是否存在*/  
25   if(msqid < 0){  
26     msqid = msgget(MSGKEY,IPC_CREAT|0666);/*创建消息队列*/  
27     if(msqid <0){  
28     printf("failed to create msq | errno=%d [%s]
",errno,strerror(errno));  
29     exit(-1);  
30     }  
31   }   
32    
33   while (1){  
34     printf("input message type(end:0):");  
35     scanf("%d",&msg_type);  
36     if (msg_type == 0)  
37        break;  
38     printf("input message to be sent:");  
39     scanf ("%s",str);  
40     msgs.msgtype = msg_type;  
41     strcpy(msgs.msgtext, str);  
42     /* 发送消息队列 */  
43     ret_value = msgsnd(msqid,&msgs,sizeof(struct msgstru),IPC_NOWAIT);  
44     if ( ret_value < 0 ) {  
45        printf("msgsnd() write msg failed,errno=%d[%s]
",errno,strerror(errno));  
46        exit(-1);  
47     }  
48   }  
49   msgctl(msqid,IPC_RMID,0); //删除消息队列   
50 }

消息接收端 receive.c

 1 /*receive.c */  
 2 #include <stdio.h>   
 3 #include <sys/types.h>   
 4 #include <sys/ipc.h>   
 5 #include <sys/msg.h>   
 6 #include <errno.h>   
 7   
 8 #define MSGKEY 1024   
 9   
10 struct msgstru  
11 {  
12    long msgtype;  
13    char msgtext[2048];  
14 };  
15   
16 /*子进程，监听消息队列*/  
17 void childproc(){  
18   struct msgstru msgs;  
19   int msgid,ret_value;  
20   char str[512];  
21     
22   while(1){  
23      msgid = msgget(MSGKEY,IPC_EXCL );/*检查消息队列是否存在 */  
24      if(msgid < 0){  
25         printf("msq not existed! errno=%d [%s]
",errno,strerror(errno));  
26         sleep(2);  
27         continue;  
28      }  
29      /*接收消息队列*/  
30      ret_value = msgrcv(msgid,&msgs,sizeof(struct msgstru),0,0);  
31      printf("text=[%s] pid=[%d]
",msgs.msgtext,getpid());  
32   }  
33   return;  
34 }  
35   
36 void main()  
37 {  
38   int i,cpid;  
39   
40   /* create 5 child process */  
41   for (i=0;i<5;i++){  
42      cpid = fork();  
43      if (cpid < 0)  
44         printf("fork failed
");  
45      else if (cpid ==0) /*child process*/  
46         childproc();  
47   }  
48 }  
49

ps:消息队列与管道的区别

消息队列与管道的区别以及有名管道相比，具有更大的灵活性，首先，它提供有格式字节流，有利于减少开发人员的工作量；

其次，消息具有类型，在实际应用中，可作为优先级使用。这两点是管道以及有名管道所不能比的。同样，消息队列可以在几个进程间复用，而不管这几个进程是否具有亲缘关系，这一点与有名管道很相似；但消息队列是随内核持续的，与有名管道（随进程持续）相比，生命力更强，应用空间更大。