Linux中进程间通信

一、整体大纲

二、进程间通信概念及方法

Linux环境下,进程地址空间相互独立,每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到,所以进程和进程之间不能相互访问,要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信(IPC,InterProcess Communication)。

在进程间完成数据传递需要借助操作系统提供特殊的方法,如:文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展,一些方法由于自身设计缺陷被淘汰或者弃用。现今常用的进程间通信方式有:

1)管道 (使用最简单)

2)信号 (开销最小)

3)共享映射区 (无血缘关系)

4)本地套接字 (最稳定)

三、进程间通信方法介绍

1. 管道

    (1)管道的概念:

管道是一种最基本的IPC机制,作用于有血缘关系的进程之间,完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质:

1) 其本质是一个伪文件(实为内核缓冲区)

2)由两个文件描述符引用,一个表示读端,一个表示写端。

3) 规定数据从管道的写端流入管道,从读端流出。

管道的原理: 管道实为内核使用环形队列机制,借助内核缓冲区(4k)实现。

管道的局限性:

1) 数据一旦被读走,便不在管道中存在,不可反复读取。

2) 由于管道采用半双工通信方式。因此,数据只能在一个方向上流动。

3) 只能在有公共祖先的进程间使用管道。

常见的通信方式有,单工通信、半双工通信、全双工通信。

    (2)管道相关函数

创建管道

int pipe(int pipefd[2]);               成功:0;失败:-1,设置errno

函数调用成功返回r/w两个文件描述符。无需open,但需手动close。规定:fd[0] → r; fd[1] → w,就像0对应标准输入,1对应标准输出一样。向管道文件读写数据其实是在读写内核缓冲区。

管道创建成功以后,创建该管道的进程(父进程)同时掌握着管道的读端和写端。如何实现父子进程间通信呢?通常可以采用如下步骤:

1)父进程调用pipe函数创建管道,得到两个文件描述符fd[0]、fd[1]指向管道的读端和写端。

2)父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同一管道。

3)父进程关闭管道读端,子进程关闭管道写端。父进程可以向管道中写入数据,子进程将管道中的数据读出。由于管道是利用环形队列实现的,数据从写端流入管道,从读端流出,这样就实现了进程间通信。

练习:父子进程使用管道通信,父写入字符串,子进程读出并打印到屏幕?

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <string.h>
 4
 5 int main()
 6 {
 7     int fd[2];
 8     pipe(fd);
 9     pid_t pid = fork();
10
11     if (pid == 0)
12     {
13         //子进程关闭写端
14         close(fd[1]);
15         char buf[256] = {0};
16         while(1)
17         {
18             memset(buf, 0, sizeof(buf));
19             int ret = read(fd[0], buf, sizeof(buf));
20             if (ret == 0)
21             {
22                 printf("read over!\n");
23                 break;
24             }
25             else if(ret > 0)
26             {
27                 write(STDOUT_FILENO,buf,ret);
28             }
29         }
30     }
31     else if (pid > 0)
32     {
33         //父进程关闭读端
34         close(fd[0]);
35         char buf[256] = {0};
36         int num = 0;
37         while(1)
38         {
39             memset(buf, 0, sizeof(buf));
40             sprintf(buf, "data from parent %d\n", num++);
41             write(fd[1], buf, sizeof(buf));
42             sleep(1);
43         }
44     }
45
46     return 0;
47 }

父进程写子进程读

    (3)管道的读写行为

使用管道需要注意以下4种特殊情况(假设都是阻塞I/O操作,没有设置O_NONBLOCK标志):

1)如果所有指向管道写端的文件描述符都关闭了(管道写端引用计数为0),而仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。

2) 如果有指向管道写端的文件描述符没关闭(管道写端引用计数大于0),而持有管道写端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。

3)如果所有指向管道读端的文件描述符都关闭了(管道读端引用计数为0),这时有进程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉,不终止进程。具体方法信号章节详细介绍。

4)如果有指向管道读端的文件描述符没关闭(管道读端引用计数大于0),而持有管道读端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再次write会阻塞,直到管道中有空位置了才写入数据并返回。

    总结:

1)读管道:  1. 管道中有数据,read返回实际读到的字节数。

2. 管道中无数据:

(1) 管道写端被全部关闭,read返回0 (好像读到文件结尾)

(2) 写端没有全部被关闭,read阻塞等待(不久的将来可能有数据递达,此时会让出cpu)

2)写管道:  1. 管道读端全部被关闭, 进程异常终止(也可使用捕捉SIGPIPE信号,使进程不终止)

2. 管道读端没有全部关闭:

(1) 管道已满,write阻塞。

(2) 管道未满,write将数据写入,并返回实际写入的字节数。

练习1:使用管道实现父子进程间通信,完成:ls | wc -l。假定父进程实现ls,子进程实现wc?

注意:ls命令正常会将结果集写出到stdout,但现在会写入管道的写端;wc -l 正常应该从stdin读取数据,但此时会从管道的读端读。

 1 #include <stdio.h>
 2 #include <unistd.h>
 3
 4 int main()
 5 {
 6     int fd[2];
 7     pipe(fd);
 8
 9     pid_t pid = fork();
10     if(pid == 0){
11         //son
12         //son -- > ls
13         //关闭 写端
14         close(fd[1]);
15         //1. 先重定向
16         dup2(fd[0], STDIN_FILENO);//标准输入重定向到管道写端
17         //2. execlp
18         execlp("wc","wc","-l",NULL);
19     }else if(pid > 0){
20         //parent
21         //关闭读端
22         close(fd[0]);
23         //1. 先重定向,标准输出重定向到管道读端
24         dup2(fd[1], STDOUT_FILENO);
25         //2. execlp
26         execlp("ls","ls",NULL);
27     }
28
29     return 0;
30 }

实现父进程ls 子进程wc -l

 1 #include <stdio.h>
 2 #include <unistd.h>
 3
 4 int main()
 5 {
 6     int fd[2];
 7     pipe(fd);
 8
 9     pid_t pid = fork();
10     if(pid == 0){
11         //son
12         //son -- > ps
13         //关闭 读端
14         close(fd[0]);
15         //1. 先重定向
16         dup2(fd[1],STDOUT_FILENO);//标准输出重定向到管道写端
17         //2. execlp
18         execlp("ps","ps","aux",NULL);
19     }else if(pid > 0){
20         //parent
21         //关闭写端
22         close(fd[1]);
23         //1. 先重定向,标准输入重定向到管道读端
24         dup2(fd[0],STDIN_FILENO);
25         //2. execlp
26         execlp("grep","grep","bash",NULL);
27     }
28
29     return 0;
30 }

父子进程实现ps aux | grep bash

执行结果分析:程序执行,发现程序执行结束,shell还在阻塞等待用户输入。这是因为,shell → fork → ./pipe2, 程序pipe2的子进程将stdin重定向给管道,父进程执行的ls会将结果集通过管道写给子进程。若父进程在子进程打印wc的结果到屏幕之前被shell调用wait回收,shell就会先输出$提示符。

练习2:使用管道实现兄弟进程间通信。 兄:ls  弟: wc -l  父:等待回收子进程?要求,使用“循环创建N个子进程”模型创建兄弟进程,使用循环因子i标示。注意管道读写行为。

实现思路:父进程关闭读写端,两个子进程,一个关闭管道的读端去写,一个关闭管道的写端去读。

 1 #include <stdio.h>
 2 #include <unistd.h>
 3
 4 int main()
 5 {
 6     int fd[2];
 7     pid_t pid;
 8     int n = 2, i = 0;
 9     pipe(fd);
10
11     for (i = 0; i < n; i++)
12     {
13         pid = fork();
14         if (pid == 0)
15         {
16             break;
17         }
18     }
19
20     //兄弟进程
21     if (i == 0)
22     {
23         printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
24         //1. 关闭写端
25         close(fd[1]);
26         //2. 先重定向
27         dup2(fd[0], STDIN_FILENO);//标准输入重定向到管道写端
28         //3. 执行execlp
29         execlp("wc","wc","-l",NULL);
30
31     }
32     //兄弟进程
33     else if (i == 1)
34     {
35         printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
36         //1. 关闭读端
37         close(fd[0]);
38         //2. 先重定向,标准输出重定向到管道读端
39         dup2(fd[1], STDOUT_FILENO);
40         //3. execlp
41         execlp("ls","ls",NULL);
42
43     }
44
45     else if (i == 2)
46     {
47         //parent
48         //父亲需要关闭读写两端
49         close(fd[0]);
50         close(fd[1]);
51         //回收子进程
52         wait(NULL);
53         wait(NULL);
54     }
55
56     return 0;
57 }

兄弟进程间实现ls | wc -l

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/wait.h>
 5
 6 int main()
 7 {
 8     int fd[2];
 9     pipe(fd);
10     pid_t pid;
11     int n =2,i = 0;
12     for(i = 0; i < n; i ++){
13         pid = fork();
14         if(pid == 0){
15             break;
16         }
17     }
18
19     //i = 0 ,代表兄长,1 - 代表弟弟,2- 父亲
20     if(i == 0){
21         //兄长进程
22         //1. 关闭读端
23         close(fd[0]);
24         //2. 重定向
25         dup2(fd[1],STDOUT_FILENO);
26         //3. 执行 execlp
27         execlp("ps","ps","aux",NULL);
28
29     }else if(i == 1){
30         //弟弟
31         //1. 关闭写端
32         close(fd[1]);
33         //2. 重定向
34         dup2(fd[0],STDIN_FILENO);
35         //3. 执行ececlp
36         execlp("grep","grep","bash",NULL);
37
38     }else if(i == 2){
39         //parent
40         //父亲需要关闭读写两端
41         close(fd[0]);
42         close(fd[1]);
43         //回收子进程
44         wait(NULL);
45         wait(NULL);
46     }
47
48
49     return 0;
50 }

兄弟进程实现ps aux | grep bash

测试:是否允许,一个pipe有一个写端多个读端呢?是否允许有一个读端多个写端呢?

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <string.h>
  4
  5 int main()
  6 {
  7     int fd[2];
  8     pid_t pid;
  9     int n = 3, i = 0;
 10     pipe(fd);
 11
 12     for (i = 0; i < n; i++)
 13     {
 14         pid = fork();
 15         if (pid == 0)
 16         {
 17             break;
 18         }
 19     }
 20
 21     //兄弟进程
 22     if (i == 0)
 23     {
 24         printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
 25         //1. 关闭写端
 26         close(fd[1]);
 27         //2. 先重定向
 28         dup2(fd[0], STDIN_FILENO);//标准输入重定向到管道写读端
 29         //3. 执行execlp
 30         char buf[256] = {0};
 31         while(1)
 32         {
 33             memset(buf, 0, sizeof(buf));
 34             int ret =  read(fd[0], buf, sizeof(buf));
 35             if (ret == 0)
 36             {
 37                 printf("read over");
 38                 break;
 39             }
 40         }
 41     }
 42
 43     //兄弟进程
 44     else if (i == 1)
 45     {
 46         printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
 47         //1. 关闭读端
 48         close(fd[1]);
 49         //2. 先重定向,标准输出重定向到管道读端
 50         dup2(fd[0], STDIN_FILENO);
 51         char buf[256] = {0};
 52         while(1)
 53         {
 54             memset(buf, 0, sizeof(buf));
 55             int ret =  read(fd[0], buf, sizeof(buf));
 56             if (ret == 0)
 57             {
 58                 printf("read over");
 59                 break;
 60             }
 61         }
 62     }
 63     //兄弟进程
 64     else if (i == 2)
 65     {
 66         printf("Brother3 pid = %d, ppid = %d\n", getpid(), getppid());
 67         //1. 关闭读端
 68         close(fd[0]);
 69         //2. 先重定向,标准输出重定向到管道读端
 70         dup2(fd[1], STDOUT_FILENO);
 71         //3. 写数据到写端
 72         int num = 0;
 73         char buf[256] = {0};
 74         while(1)
 75         {
 76             memset(buf, 0, sizeof(buf));
 77             sprintf(buf, "from broth3 %d\n", num++);
 78             int ret = write(fd[1], buf, sizeof(buf));
 79             if (ret == -1)
 80             {
 81                 perror("write err:");
 82                 break;
 83             }
 84             sleep(1);
 85         }
 86     }
 87    else if (i == 3)
 88     {
 89         //parent
 90         //父亲需要关闭读写两端
 91         close(fd[0]);
 92         close(fd[1]);
 93         //回收子进程
 94         wait(NULL);
 95         wait(NULL);
 96         wait(NULL);
 97     }
 98
 99     return 0;
100 }

一写多读

结论:一个读多个写会hang住。

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <string.h>
  4
  5 int main()
  6 {
  7     int fd[2];
  8     pid_t pid;
  9     int n = 3, i = 0;
 10     pipe(fd);
 11
 12     for (i = 0; i < n; i++)
 13     {
 14         pid = fork();
 15         if (pid == 0)
 16         {
 17             break;
 18         }
 19     }
 20
 21     //兄弟进程
 22     if (i == 0)
 23     {
 24         printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
 25         //1. 关闭写端
 26         close(fd[1]);
 27         //2. 先重定向
 28         dup2(fd[0], STDIN_FILENO);//标准输入重定向到管道写读端
 29         //3. 执行execlp
 30         char buf[256] = {0};
 31         while(1)
 32         {
 33             memset(buf, 0, sizeof(buf));
 34             int ret =  read(fd[0], buf, sizeof(buf));
 35             if (ret == 0)
 36             {
 37                 printf("read over");
 38                 break;
 39             }
 40         }
 41     }
 42     //兄弟进程
 43     else if (i == 1)
 44     {
 45         printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
 46         //1. 关闭读端
 47         close(fd[0]);
 48         //2. 先重定向,标准输出重定向到管道读端
 49         dup2(fd[1], STDOUT_FILENO);
 50         int num = 0;
 51         char buf[256] = {0};
 52         while(1)
 53         {
 54             memset(buf, 0, sizeof(buf));
 55             sprintf(buf, "from broth2 %d\n", num++);
 56             int ret = write(fd[1], buf, sizeof(buf));
 57             if (ret == -1)
 58             {
 59                 perror("write err:");
 60                 break;
 61             }
 62             sleep(1);
 63         }
 64     }
 65     //兄弟进程
 66     else if (i == 2)
 67     {
 68         printf("Brother3 pid = %d, ppid = %d\n", getpid(), getppid());
 69         //1. 关闭读端
 70         close(fd[0]);
 71         //2. 先重定向,标准输出重定向到管道读端
 72         dup2(fd[1], STDOUT_FILENO);
 73         //3. 写数据到写端
 74         int num = 0;
 75         char buf[256] = {0};
 76         while(1)
 77         {
 78             memset(buf, 0, sizeof(buf));
 79             sprintf(buf, "from broth3 %d\n", num++);
 80             int ret = write(fd[1], buf, sizeof(buf));
 81             if (ret == -1)
 82             {
 83                 perror("write err:");
 84                 break;
 85             }
 86             sleep(1);
 87         }
 88     }
 89     else if (i == 3)
 90     {
 91         //parent
 92         //父亲需要关闭读写两端
 93         close(fd[0]);
 94         close(fd[1]);
 95         //回收子进程
 96         wait(NULL);
 97         wait(NULL);
 98         wait(NULL);
 99     }
100
101     return 0;
102 }

多写一读

结论:一个写多个读会hang住。

    (4)管道缓冲区大小

可以使用ulimit -a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。通常为:

pipe size            (512 bytes, -p) 8

也可以使用fpathconf函数,借助参数        选项来查看。使用该宏应引入头文件<unistd.h>

long fpathconf(int fd, int name);      成功:返回管道的大小         失败:-1,设置errno

    (5)管道优劣

优点:简单,相比信号,套接字实现进程间通信,简单很多。

缺点:1. 只能单向通信,双向通信需建立两个管道。

2. 只能用于父子、兄弟进程(有共同祖先)间通信。该问题后来使用fifo有名管道解决。

2. FIFO

FIFO常被称为有名管道,以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间。但通过FIFO,不相关的进程也能交换数据。

FIFO是Linux基础文件类型中的一种。但FIFO文件在磁盘上没有数据块,仅仅用来标识内核中一条通道。各进程可以打开这个文件进行read/write,实际上是在读写内核通道,这样就实现了进程间通信。

创建方式:

1. 命令:mkfifo 管道名

2. 库函数:int mkfifo(const char *pathname,  mode_t mode);  成功:0; 失败:-1

一旦使用mkfifo创建了一个FIFO,就可以使用open打开它,常见的文件I/O函数都可用于fifo。如:close、read、write、unlink等。

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <fcntl.h>
 6 #include <string.h>
 7 #include <errno.h>
 8
 9 int main(int argc,char * argv[])
10 {
11     if(argc != 2){
12         printf("./a.out fifoname\n");
13         return -1;
14     }
15
16     int ret = mkfifo(argv[1], 0666);
17     if (ret < 0 && errno != EEXIST)
18     {
19         printf("create fifo file %s failed\n", argv[1]);
20         return -1;
21     }
22
23     // 创建一个 myfifo 文件
24     //打开fifo文件
25     printf("begin open ....\n");
26     int fd = open(argv[1],O_WRONLY);
27     printf("end open ....\n");
28     //写
29     char buf[256];
30     int num = 1;
31     while(1){
32         memset(buf,0x00,sizeof(buf));
33         sprintf(buf,"from write data:%04d",num++);
34         write(fd,buf,strlen(buf));
35         sleep(1);
36         //循环写
37     }
38     //关闭描述符
39     close(fd);
40     return 0;
41 }

fifo_w.c

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <fcntl.h>
 6 #include <string.h>
 7
 8 int main(int argc,char *argv[])
 9 {
10     if(argc != 2){
11         printf("./a.out fifoname\n");
12         return -1;
13     }
14     printf("begin oepn read...\n");
15     int fd = open(argv[1],O_RDONLY);
16     printf("end oepn read...\n");
17
18     char buf[256];
19     int ret;
20     while(1){
21         //循环读
22         memset(buf,0x00,sizeof(buf));
23         ret = read(fd,buf,sizeof(buf));
24         if(ret > 0){
25             printf("read:%s\n",buf);
26         }
27     }
28
29     close(fd);
30     return 0;
31 }

fifo_r.c

注意:

FIFOs
        Opening the read or write end of a FIFO blocks until the other end is also opened (by another process or thread). See fifo(7) for further details.

open注意事项,打开fifo文件的时候,read端会阻塞等待write端open,write端同理,也会阻塞等待另外一端打开。

3. 共享存储映射

 (1)文件进程间通信

使用文件也可以完成IPC,理论依据是,fork后,父子进程共享文件描述符。也就共享打开的文件。

 (2)存储映射IO

存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据,就相当于读文件中的相应字节。于此类似,将数据存入缓冲区,则相应的字节就自动写入文件。这样,就可在不适用read和write函数的情况下,使用地址(指针)完成I/O操作。

使用这种方法,首先应通知内核,将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

    1)mmap函数

void *mmap(void *adrr, size_t length, int prot, int flags, int fd, off_t offset);

返回:

成功:返回创建的映射区首地址;

失败:MAP_FAILED宏

参数:

addr:建立映射区的首地址,由Linux内核指定。使用时,直接传递NULL

length:欲创建映射区的大小

prot: 映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE

flags:标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)

MAP_SHARED:  会将映射区所做的操作反映到物理设备(磁盘)上。

MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。

fd:用来建立映射区的文件描述符

offset:映射文件的偏移(4k的整数倍)

    2)munmap函数

同malloc函数申请内存空间类似的,mmap建立的映射区在使用结束后也应调用类似free的函数来释放。

int munmap(void *addr, size_t length);  成功:0; 失败:-1

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <fcntl.h>
 6 #include <sys/mman.h>
 7 #include <string.h>
 8
 9 int main()
10 {
11     int fd = open("mem.txt",O_RDWR);//创建并且截断文件
12     //int fd = open("mem.txt",O_RDWR|O_CREAT|O_TRUNC,0664);//创建并且截断文件
13
14     ftruncate(fd,8);
15     //创建映射区
16    char *mem = mmap(NULL,20,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
17     //char *mem = mmap(NULL,8,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);
18
19     if(mem == MAP_FAILED){
20         perror("mmap err");
21         return -1;
22     }
23     close(fd);
24     //拷贝数据
25     strcpy(mem,"helloworld");
26 //    mem++;
27     //释放mmap
28     printf("mem = %s\n", mem);
29
30     if(munmap(mem,20) < 0){
31         perror("munmap err");
32     }
33     return 0;
34 }

mmap.c

执行结果:

执行mmap_size之前,mem.txt大小为30,代码中 ftruncate(fd,8); 将文件截断为8个字节大小,共享映射为20个字节,虽然文件大小(8) < 映射区大小(20),映射区可以存储helloworld(10),同时修改文件mem.txt内容。

[[email protected] 09-linux-day06]# cat mem.txt
*****************************
[[email protected] 09-linux-day06]# ./mmap_size
mem = helloworld
[[email protected] 09-linux-day06]# cat mem.txt
hellowor

借鉴malloc和free函数原型,尝试装自定义函数smalloc,sfree来完成映射区的建立和释放。思考函数接口该如何设计?

mmap九问:
   1. 如果更改mem变量的地址,释放的时候munmap,传入mem还能成功吗? 不能!!

2. 如果对mem越界操作会怎么样? 文件的大小对映射区操作有影响,尽量避免。

3. 如果文件偏移量随便填个数会怎么样? offset必须是 4k的整数倍

4 如果文件描述符先关闭,对mmap映射有没有影响?没有影响

5. open的时候,可以新创建一个文件来创建映射区吗?不可以用大小为0的文件

6. open文件选择O_WRONLY,可以吗? 不可以: Permission denied

7. 当选择MAP_SHARED的时候,open文件选择O_RDONLY,prot可以选择PROT_READ|PROT_WRITE吗?Permission denied ,SHARED的时候,映射区的权限 <= open文件的权限

8. mmap什么情况下会报错?很多情况

9. 如果不判断返回值会怎么样? 会死的很难堪!!

总结:使用mmap时务必注意以下事项:

1. 创建映射区的过程中,隐含着一次对映射文件的读操作。

2. 当MAP_SHARED时,要求:映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓,因为mmap中的权限是对内存的限制。

3. 映射区的释放与文件关闭无关。只要映射建立成功,文件可以立即关闭。

4. 特别注意,当映射文件大小为0时,不能创建映射区。所以:用于映射的文件必须要有实际大小!!    mmap使用时常常会出现总线错误,通常是由于共享文件存储空间大小引起的。

5. munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。

6. 文件偏移量必须为4K的整数倍

7. mmap创建映射区出错概率非常高,一定要检查返回值,确保映射区建立成功再进行后续操作。

 (3)mmap父子进程间通信

父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags:

MAP_PRIVATE:  (私有映射)  父子进程各自独占映射区;

MAP_SHARED:  (共享映射)  父子进程共享映射区;

练习:父进程创建映射区,然后fork子进程,子进程修改映射区内容,而后,父进程读取映射区内容,查验是否共享。

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <sys/mman.h>
 6 #include <fcntl.h>
 7 #include <sys/wait.h>
 8
 9 int main()
10 {
11     // 先创建映射区
12     int fd = open("mem.txt",O_RDWR);
13     int *mem = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
14     //int *mem = mmap(NULL,4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
15     if(mem == MAP_FAILED){
16         perror("mmap err");
17         return -1;
18     }
19     // fork子进程
20     pid_t pid = fork();
21
22     // 父进程和子进程交替修改数据
23     if(pid == 0 ){
24         //son
25         *mem = 100;
26         printf("child,*mem = %d\n",*mem);
27         sleep(3);
28         printf("child,*mem = %d\n",*mem);
29     }
30     else if(pid > 0){
31         //parent
32         sleep(1);
33         printf("parent,*mem=%d\n",*mem);
34         *mem = 1001;
35         printf("parent,*mem=%d\n",*mem);
36         wait(NULL);
37     }
38
39     munmap(mem,4);
40     close(fd);
41
42     return 0;
43 }

父子进程共享映射区

结论:父子进程共享:1. 打开的文件  2. mmap建立的映射区(但必须要使用MAP_SHARED)

 (4)匿名映射

通过使用我们发现,使用映射区来完成文件读写操作十分方便,父子进程间通信也较容易。但缺陷是,每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件,创建好了再unlink、close掉,比较麻烦。 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法,无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。

使用MAP_ANONYMOUS (或MAP_ANON), 如:

int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0); 

需注意的是,MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义,可使用如下两步来完成匿名映射区的建立。

1)fd = open("/dev/zero", O_RDWR);

2)p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <sys/mman.h>
 6 #include <fcntl.h>
 7 #include <sys/wait.h>
 8
 9 int main()
10 {
11     int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);
12
13     if(mem == MAP_FAILED){
14         perror("mmap err");
15         return -1;
16     }
17
18     pid_t pid = fork();
19
20     if(pid == 0 ){
21         //son
22         *mem = 100;
23         printf("child,*mem=%d\n",*mem);
24         sleep(3);
25         printf("child,*mem=%d\n",*mem);
26     }else if(pid > 0){
27         //parent
28         sleep(1);
29         printf("parent,*mem=%d\n",*mem);
30         *mem = 200;
31         printf("parent,*mem=%d\n",*mem);
32         wait(NULL);
33     }
34
35     munmap(mem,4);
36
37     return 0;
38 }

mmap_anon.c

(5)mmap无血缘关系进程间通信

实质上mmap是内核借助文件帮我们创建了一个映射区,多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享,因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可。若想实现共享,当然应该使用MAP_SHARED了。

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <sys/mman.h>
 6 #include <fcntl.h>
 7 #include <sys/wait.h>
 8
 9 typedef struct  _Student{
10     int sid;
11     char sname[20];
12 }Student;
13
14 int main(int argc,char *argv[])
15 {
16     if(argc != 2){
17         printf("./a.out filename\n");
18         return -1;
19     }
20
21     // 1. open file
22     int fd = open(argv[1],O_RDWR|O_CREAT|O_TRUNC,0666);
23     int length = sizeof(Student);
24
25     ftruncate(fd,length);
26
27     // 2. mmap
28     Student * stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
29
30     if(stu == MAP_FAILED){
31         perror("mmap err");
32         return -1;
33     }
34     int num = 1;
35     // 3. 修改内存数据
36     while(1){
37         stu->sid = num;
38         sprintf(stu->sname,"from mmap write-%03d",num++);
39         sleep(1);//相当于没隔1s修改一次映射区的内容
40     }
41     // 4. 释放映射区和关闭文件描述符
42     munmap(stu,length);
43     close(fd);
44
45     return 0;
46 }

mmap_w.c

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <sys/mman.h>
 6 #include <fcntl.h>
 7 #include <sys/wait.h>
 8
 9 typedef struct _Student{
10     int sid;
11     char sname[20];
12 }Student;
13
14 int main(int argc,char *argv[])
15 {
16     //open file
17     int fd = open(argv[1],O_RDWR);
18     //mmap
19     int length = sizeof(Student);
20     Student *stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
21     if(stu == MAP_FAILED){
22         perror("mmap err");
23         return -1;
24     }
25     //read data
26     while(1){
27         printf("sid=%d,sname=%s\n",stu->sid,stu->sname);
28         sleep(1);
29     }
30     //close and munmap
31     munmap(stu,length);
32     close(fd);
33     return 0;
34 }

mmap_r.c

练习:

1.通过命名管道传输数据,进程A和进程B,进程A将一个文件(MP3)发送给进程B?
    2.实现多进程拷贝文件?

实现思路:

代码实现:

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <sys/types.h>
  4 #include <fcntl.h>
  5 #include <sys/mman.h>
  6 #include <stdlib.h>
  7 #include <string.h>
  8 #include <sys/stat.h>
  9
 10 int main(int argc, char *argv[])
 11 {
 12     //拷贝文件起的进程数,通过参数输入,默认是5个
 13     int n = 5;
 14     //输入参数至少是3,第4个参数是进程个数
 15     if (argc < 3)
 16     {
 17         printf("./a.out src dst [n]\n");
 18         return -1;
 19     }
 20     if (argc == 4)
 21     {
 22         n = atoi(argv[3]);
 23     }
 24
 25     //打开源文件
 26     int srcfd = open(argv[1], O_RDONLY);
 27     if (srcfd < 0)
 28     {
 29         perror("open src err:");
 30         exit(1);
 31     }
 32
 33     //打开目标文件
 34     int dstfd = open(argv[2], O_RDWR|O_CREAT|O_TRUNC, 0644);
 35     if (dstfd < 0)
 36     {
 37         perror("open dst err:");
 38         exit(1);
 39     }
 40
 41     //目标拓展,从源文件获得文件大小,stat
 42     struct stat sb;
 43     stat(argv[1], &sb);
 44     //将目标文件设置为和源文件大小相同
 45     int len = sb.st_size;
 46     truncate(argv[2], len);
 47
 48     //将源文件映射到缓冲区
 49     char *psrc = mmap(NULL, len, PROT_READ, MAP_SHARED, srcfd, 0);
 50     if (psrc == MAP_FAILED)
 51     {
 52         perror("mmap src err:");
 53         exit(1);
 54     }
 55
 56     //将目标文件映射
 57     char *pdst = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, dstfd, 0);
 58     if (pdst == MAP_FAILED)
 59     {
 60         perror("mmap pdst err:");
 61         exit(1);
 62     }
 63     //创建多个子进程
 64     int i = 0;
 65     for (i = 0; i < n; i++)
 66     {
 67         if (fork() == 0)
 68         {
 69             break;
 70         }
 71     }
 72     //计算子进程需要拷贝的起点大小
 73     int cpsize = len/n;
 74     int mod = len%n;
 75     //数据拷贝,memcpy
 76     if (i < n)
 77     {
 78         //最后一个子进程
 79         if (i == n-1)
 80         {
 81             memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize+mod);
 82         }
 83         else
 84         {
 85             memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize);
 86         }
 87     }
 88     else
 89     {
 90         for (i = 0; i < n; i++)
 91         {
 92             //回收子线程
 93             wait(NULL);
 94         }
 95     }
 96     //释放映射区
 97     if (munmap(psrc, len) < 0)
 98     {
 99         perror("munmap src err:");
100         exit(1);
101     }
102
103     if (munmap(pdst, len) < 0)
104     {
105         perror("munmap dst err:");
106         exit(1);
107     }
108
109     //关闭文件
110     close(srcfd);
111     close(dstfd);
112
113     return 0;
114 }

多进程文件拷贝

原文地址:https://www.cnblogs.com/xuejiale/p/10803928.html

时间: 2024-10-31 20:51:38

Linux中进程间通信的相关文章

(转载)linux下的僵尸进程处理SIGCHLD信号Linux环境进程间通信(五): 共享内存(下)

Linux环境进程间通信(五): 共享内存(下) 在共享内存(上)中,主要围绕着系统调用mmap()进行讨论的,本部分将讨论系统V共享内存,并通过实验结果对比来阐述两者的异同.系统V共享内存指的是把所有共享数据放在共享内存区域(IPC shared memory region),任何想要访问该数据的进程都必须在本进程的地址空间新增一块内存区域,用来映射存放共享数据的物理内存页面. 系统调用mmap()通过映射一个普通文件实现共享内存.系统V则是通过映射特殊文件系统shm中的文件实现进程间的共享内

【转载】Linux的进程间通信-信号量

原文:Linux的进程间通信-信号量 Linux的进程间通信-信号量 版权声明: 本文章内容在非商业使用前提下可无需授权任意转载.发布. 转载.发布请务必注明作者和其微博.微信公众号地址,以便读者询问问题和甄误反馈,共同进步. 微博ID:orroz 微信公众号:Linux系统技术 前言 信号量又叫信号灯,也有人把它叫做信号集,本文遵循<UNIX环境高级编程>的叫法,仍称其为信号量.它的英文是semaphores,本意是“旗语”“信号”的意思.由于其叫法中包含“信号”这个关键字,所以容易跟另一个

诠释Linux中『一切都是文件』概念和相应的文件类型

在 Unix 和它衍生的比如 Linux 系统中,一切都可以看做文件.虽然它仅仅只是一个泛泛的概念,但这是事实.如果有不是文件的,那它一定是正运行的进程. 要理解这点,可以举个例子,您的根目录(/)的空间充斥着不同类型的 Linux 文件.当您创建一个文件或向系统传输一个文件时,它会在物理磁盘上占据的一些空间,而且是一个特定的格式(文件类型). 虽然 Linux 系统中文件和目录没有什么不同,但目录还有一个重要的功能,那就是有结构性的分组存储其它文件,以方便查找访问.所有的硬件组件都表示为文件,

Linux高级进程间通信:UNIX域套接字

UNIX域套接字简介 UNIX域套接字用于在同一台机器上运行的进程间的通信.虽然因特网域套接字可用于同一目的,但UNIX域套接字的效率更高.UNIX域套接字仅仅复制数据,它们并不执行协议处理,不需要添加和删除网络报头,无需计算检验和,不要产生顺序号,无需发送确认报文. UNIX域套接字提供流和数据报两种接口.UNIX域数据报服务是可靠的,既不会丢失消息也不会传递错误.UNIX域套接字是套接字和管道之间的混合物.为了创建一对非命名的.相互连接的UNIX域套接字,用户可以使用它们面向网络的域套接字接

Linux中进程控制块PCB-------task_struct结构体结构

Linux中task_struct用来控制管理进程,结构如下: struct task_struct { //说明了该进程是否可以执行,还是可中断等信息    volatile long state;   //Flage 是进程号,在调用fork()时给出 unsigned long flags;   //进程上是否有待处理的信号 int sigpending;    //进程地址空间,区分内核进程与普通进程在内存存放的位置不同 mm_segment_t addr_limit; //0-0xBF

Linux环境进程间通信(一):管道及有名管道

在本系列序中作者概述了 linux 进程间通信的几种主要手段.其中管道和有名管道是最早的进程间通信机制之一,管道可用于具有亲缘关系进程间的通信,有名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程间的通信. 认清管道和有名管道的读写规则是在程序中应用它们的关键,本文在详细讨论了管道和有名管道的通信机制的基础上,用实例对其读写规则进行了程序验证,这样做有利于增强读者对读写规则的感性认识,同时也提供了应用范例. 1. 管道概述及相关API应用 1.1 管道相关的关

(转)Linux环境进程间通信系列(五):共享内存

原文地址:http://www.cppblog.com/mydriverc/articles/29741.html 共享内存可以说是最有用的进程间通信方式,也是最快的 IPC 形式.两个不同进程 A . B 共享内存的意思是,同一块物理内存被映射到进程 A . B 各自的进程地址空间.进程 A 可以即时看到进程 B 对共享内存中数据的更新,反之亦然.由于多个进程共享同一块内存区域,必然需要某种同步机制,互斥锁和信号量都可以. 采用共享内存通信的一个显而易见的好处是效率高,因为进程可以直接读写内存

Linux的进程间通信 - 管道

Linux的进程间通信 - 管道 版权声明: 本文章内容在非商业使用前提下可无需授权任意转载.发布. 转载.发布请务必注明作者和其微博.微信公众号地址,以便读者询问问题和甄误反馈,共同进步. 微博ID:orroz 微信公众号:Linux系统技术 前言 管道是UNIX环境中历史最悠久的进程间通信方式.本文主要说明在Linux环境上如何使用管道.阅读本文可以帮你解决以下问题: 什么是管道和为什么要有管道? 管道怎么分类? 管道的实现是什么样的? 管道有多大? 管道的大小是不是可以调整?如何调整? 什

Linux环境进程间通信:共享内存

共享内存简介 共享内存允许两个或多个进程共享一给定的存储区.因为数据不需要在客户进程和服务器进程之间复制,所以这是最快的一种IPC.共享内存的方式有两种:mmap()系统调用和系统V共享内存. mmap()系统调用 mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存.普通文件被映射到进程地址空间后,进程可以向访问普通内存一样对文件进行访问,不必再调用read(),write()等操作. 注:实际上,mmap()系统调用并不是完全为了用于共享内存而设计的.它本身提供了不同于一般对普