一、整体大纲

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

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

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

 #include <stdio.h>
#include <unistd.h>
#include <string.h> int main()
{
int fd[];
pipe(fd);
pid_t pid = fork(); if (pid == )
{
//子进程关闭写端
close(fd[]);
char buf[] = {};
while()
{
memset(buf, , sizeof(buf));
int ret = read(fd[], buf, sizeof(buf));
if (ret == )
{
printf("read over!\n");
break;
}
else if(ret > )
{
write(STDOUT_FILENO,buf,ret);
}
}
}
else if (pid > )
{
//父进程关闭读端
close(fd[]);
char buf[] = {};
int num = ;
while()
{
memset(buf, , sizeof(buf));
sprintf(buf, "data from parent %d\n", num++);
write(fd[], buf, sizeof(buf));
sleep();
}
} return ;
} 父进程写子进程读

父进程写子进程读

(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读取数据,但此时会从管道的读端读。

 #include <stdio.h>
#include <unistd.h> int main()
{
int fd[];
pipe(fd); pid_t pid = fork();
if(pid == ){
//son
//son -- > ls
//关闭 写端
close(fd[]);
//1. 先重定向
dup2(fd[], STDIN_FILENO);//标准输入重定向到管道写端
//2. execlp
execlp("wc","wc","-l",NULL);
}else if(pid > ){
//parent
//关闭读端
close(fd[]);
//1. 先重定向,标准输出重定向到管道读端
dup2(fd[], STDOUT_FILENO);
//2. execlp
execlp("ls","ls",NULL);
} return ;
} 实现父进程ls 子进程wc -l

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

 #include <stdio.h>
#include <unistd.h> int main()
{
int fd[];
pipe(fd); pid_t pid = fork();
if(pid == ){
//son
//son -- > ps
//关闭 读端
close(fd[]);
//1. 先重定向
dup2(fd[],STDOUT_FILENO);//标准输出重定向到管道写端
//2. execlp
execlp("ps","ps","aux",NULL);
}else if(pid > ){
//parent
//关闭写端
close(fd[]);
//1. 先重定向,标准输入重定向到管道读端
dup2(fd[],STDIN_FILENO);
//2. execlp
execlp("grep","grep","bash",NULL);
} return ;
} 父子进程实现ps aux | grep bash

父子进程实现ps aux | grep bash

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

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

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

 #include <stdio.h>
#include <unistd.h> int main()
{
int fd[];
pid_t pid;
int n = , i = ;
pipe(fd); for (i = ; i < n; i++)
{
pid = fork();
if (pid == )
{
break;
}
} //兄弟进程
if (i == )
{
printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭写端
close(fd[]);
//2. 先重定向
dup2(fd[], STDIN_FILENO);//标准输入重定向到管道写端
//3. 执行execlp
execlp("wc","wc","-l",NULL); }
//兄弟进程
else if (i == )
{
printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭读端
close(fd[]);
//2. 先重定向,标准输出重定向到管道读端
dup2(fd[], STDOUT_FILENO);
//3. execlp
execlp("ls","ls",NULL); } else if (i == )
{
//parent
//父亲需要关闭读写两端
close(fd[]);
close(fd[]);
//回收子进程
wait(NULL);
wait(NULL);
} return ;
} 兄弟进程间实现ls | wc -l

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

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h> int main()
{
int fd[];
pipe(fd);
pid_t pid;
int n =,i = ;
for(i = ; i < n; i ++){
pid = fork();
if(pid == ){
break;
}
} //i = 0 ,代表兄长,1 - 代表弟弟,2- 父亲
if(i == ){
//兄长进程
//1. 关闭读端
close(fd[]);
//2. 重定向
dup2(fd[],STDOUT_FILENO);
//3. 执行 execlp
execlp("ps","ps","aux",NULL); }else if(i == ){
//弟弟
//1. 关闭写端
close(fd[]);
//2. 重定向
dup2(fd[],STDIN_FILENO);
//3. 执行ececlp
execlp("grep","grep","bash",NULL); }else if(i == ){
//parent
//父亲需要关闭读写两端
close(fd[]);
close(fd[]);
//回收子进程
wait(NULL);
wait(NULL);
} return ;
} 兄弟进程实现ps aux | grep bash

兄弟进程实现ps aux | grep bash

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

 #include <stdio.h>
#include <unistd.h>
#include <string.h> int main()
{
int fd[];
pid_t pid;
int n = , i = ;
pipe(fd); for (i = ; i < n; i++)
{
pid = fork();
if (pid == )
{
break;
}
} //兄弟进程
if (i == )
{
printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭写端
close(fd[]);
//2. 先重定向
dup2(fd[], STDIN_FILENO);//标准输入重定向到管道写读端
//3. 执行execlp
char buf[] = {};
while()
{
memset(buf, , sizeof(buf));
int ret = read(fd[], buf, sizeof(buf));
if (ret == )
{
printf("read over");
break;
}
}
} //兄弟进程
else if (i == )
{
printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭读端
close(fd[]);
//2. 先重定向,标准输出重定向到管道读端
dup2(fd[], STDIN_FILENO);
char buf[] = {};
while()
{
memset(buf, , sizeof(buf));
int ret = read(fd[], buf, sizeof(buf));
if (ret == )
{
printf("read over");
break;
}
}
}
//兄弟进程
else if (i == )
{
printf("Brother3 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭读端
close(fd[]);
//2. 先重定向,标准输出重定向到管道读端
dup2(fd[], STDOUT_FILENO);
//3. 写数据到写端
int num = ;
char buf[] = {};
while()
{
memset(buf, , sizeof(buf));
sprintf(buf, "from broth3 %d\n", num++);
int ret = write(fd[], buf, sizeof(buf));
if (ret == -)
{
perror("write err:");
break;
}
sleep();
}
}
else if (i == )
{
//parent
//父亲需要关闭读写两端
close(fd[]);
close(fd[]);
//回收子进程
wait(NULL);
wait(NULL);
wait(NULL);
} return ;
} 一写多读

一写多读

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

 #include <stdio.h>
#include <unistd.h>
#include <string.h> int main()
{
int fd[];
pid_t pid;
int n = , i = ;
pipe(fd); for (i = ; i < n; i++)
{
pid = fork();
if (pid == )
{
break;
}
} //兄弟进程
if (i == )
{
printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭写端
close(fd[]);
//2. 先重定向
dup2(fd[], STDIN_FILENO);//标准输入重定向到管道写读端
//3. 执行execlp
char buf[] = {};
while()
{
memset(buf, , sizeof(buf));
int ret = read(fd[], buf, sizeof(buf));
if (ret == )
{
printf("read over");
break;
}
}
}
//兄弟进程
else if (i == )
{
printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭读端
close(fd[]);
//2. 先重定向,标准输出重定向到管道读端
dup2(fd[], STDOUT_FILENO);
int num = ;
char buf[] = {};
while()
{
memset(buf, , sizeof(buf));
sprintf(buf, "from broth2 %d\n", num++);
int ret = write(fd[], buf, sizeof(buf));
if (ret == -)
{
perror("write err:");
break;
}
sleep();
}
}
//兄弟进程
else if (i == )
{
printf("Brother3 pid = %d, ppid = %d\n", getpid(), getppid());
//1. 关闭读端
close(fd[]);
//2. 先重定向,标准输出重定向到管道读端
dup2(fd[], STDOUT_FILENO);
//3. 写数据到写端
int num = ;
char buf[] = {};
while()
{
memset(buf, , sizeof(buf));
sprintf(buf, "from broth3 %d\n", num++);
int ret = write(fd[], buf, sizeof(buf));
if (ret == -)
{
perror("write err:");
break;
}
sleep();
}
}
else if (i == )
{
//parent
//父亲需要关闭读写两端
close(fd[]);
close(fd[]);
//回收子进程
wait(NULL);
wait(NULL);
wait(NULL);
} return ;
} 多写一读

多写一读

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

    (4)管道缓冲区大小

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

 pipe size            ( bytes, -p) 

也可以使用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等。

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h> int main(int argc,char * argv[])
{
if(argc != ){
printf("./a.out fifoname\n");
return -;
} int ret = mkfifo(argv[], );
if (ret < && errno != EEXIST)
{
printf("create fifo file %s failed\n", argv[]);
return -;
} // 创建一个 myfifo 文件
//打开fifo文件
printf("begin open ....\n");
int fd = open(argv[],O_WRONLY);
printf("end open ....\n");
//写
char buf[];
int num = ;
while(){
memset(buf,0x00,sizeof(buf));
sprintf(buf,"from write data:%04d",num++);
write(fd,buf,strlen(buf));
sleep();
//循环写
}
//关闭描述符
close(fd);
return ;
} fifo_w.c

fifo_w.c

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h> int main(int argc,char *argv[])
{
if(argc != ){
printf("./a.out fifoname\n");
return -;
}
printf("begin oepn read...\n");
int fd = open(argv[],O_RDONLY);
printf("end oepn read...\n"); char buf[];
int ret;
while(){
//循环读
memset(buf,0x00,sizeof(buf));
ret = read(fd,buf,sizeof(buf));
if(ret > ){
printf("read:%s\n",buf);
}
} close(fd);
return ;
} fifo_r.c

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);  成功:; 失败:-
 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h> int main()
{
int fd = open("mem.txt",O_RDWR);//创建并且截断文件
//int fd = open("mem.txt",O_RDWR|O_CREAT|O_TRUNC,0664);//创建并且截断文件 ftruncate(fd,);
//创建映射区
char *mem = mmap(NULL,,PROT_READ|PROT_WRITE,MAP_SHARED,fd,);
//char *mem = mmap(NULL,8,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0); if(mem == MAP_FAILED){
perror("mmap err");
return -;
}
close(fd);
//拷贝数据
strcpy(mem,"helloworld");
// mem++;
//释放mmap
printf("mem = %s\n", mem); if(munmap(mem,) < ){
perror("munmap err");
}
return ;
} mmap.c

mmap.c

执行结果:

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

[root@centos -linux-day06]# cat mem.txt
*****************************
[root@centos -linux-day06]# ./mmap_size
mem = helloworld
[root@centos -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子进程,子进程修改映射区内容,而后,父进程读取映射区内容,查验是否共享。

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h> int main()
{
// 先创建映射区
int fd = open("mem.txt",O_RDWR);
int *mem = mmap(NULL, , PROT_READ|PROT_WRITE, MAP_SHARED, fd, );
//int *mem = mmap(NULL,4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
if(mem == MAP_FAILED){
perror("mmap err");
return -;
}
// fork子进程
pid_t pid = fork(); // 父进程和子进程交替修改数据
if(pid == ){
//son
*mem = ;
printf("child,*mem = %d\n",*mem);
sleep();
printf("child,*mem = %d\n",*mem);
}
else if(pid > ){
//parent
sleep();
printf("parent,*mem=%d\n",*mem);
*mem = ;
printf("parent,*mem=%d\n",*mem);
wait(NULL);
} munmap(mem,);
close(fd); return ;
} 父子进程共享映射区

父子进程共享映射区

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

 (4)匿名映射

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

使用MAP_ANONYMOUS (或MAP_ANON), 如:

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

需注意的是,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);

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h> int main()
{
int *mem = mmap(NULL,,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-,); if(mem == MAP_FAILED){
perror("mmap err");
return -;
} pid_t pid = fork(); if(pid == ){
//son
*mem = ;
printf("child,*mem=%d\n",*mem);
sleep();
printf("child,*mem=%d\n",*mem);
}else if(pid > ){
//parent
sleep();
printf("parent,*mem=%d\n",*mem);
*mem = ;
printf("parent,*mem=%d\n",*mem);
wait(NULL);
} munmap(mem,); return ;
} mmap_anon.c

mmap_anon.c

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

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

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h> typedef struct _Student{
int sid;
char sname[];
}Student; int main(int argc,char *argv[])
{
if(argc != ){
printf("./a.out filename\n");
return -;
} // 1. open file
int fd = open(argv[],O_RDWR|O_CREAT|O_TRUNC,);
int length = sizeof(Student); ftruncate(fd,length); // 2. mmap
Student * stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,); if(stu == MAP_FAILED){
perror("mmap err");
return -;
}
int num = ;
// 3. 修改内存数据
while(){
stu->sid = num;
sprintf(stu->sname,"from mmap write-%03d",num++);
sleep();//相当于没隔1s修改一次映射区的内容
}
// 4. 释放映射区和关闭文件描述符
munmap(stu,length);
close(fd); return ;
} mmap_w.c

mmap_w.c

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h> typedef struct _Student{
int sid;
char sname[];
}Student; int main(int argc,char *argv[])
{
//open file
int fd = open(argv[],O_RDWR);
//mmap
int length = sizeof(Student);
Student *stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,);
if(stu == MAP_FAILED){
perror("mmap err");
return -;
}
//read data
while(){
printf("sid=%d,sname=%s\n",stu->sid,stu->sname);
sleep();
}
//close and munmap
munmap(stu,length);
close(fd);
return ;
} mmap_r.c

mmap_r.c

练习:

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

实现思路:

代码实现:

 #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h> int main(int argc, char *argv[])
{
//拷贝文件起的进程数,通过参数输入,默认是5个
int n = ;
//输入参数至少是3,第4个参数是进程个数
if (argc < )
{
printf("./a.out src dst [n]\n");
return -;
}
if (argc == )
{
n = atoi(argv[]);
} //打开源文件
int srcfd = open(argv[], O_RDONLY);
if (srcfd < )
{
perror("open src err:");
exit();
} //打开目标文件
int dstfd = open(argv[], O_RDWR|O_CREAT|O_TRUNC, );
if (dstfd < )
{
perror("open dst err:");
exit();
} //目标拓展,从源文件获得文件大小,stat
struct stat sb;
stat(argv[], &sb);
//将目标文件设置为和源文件大小相同
int len = sb.st_size;
truncate(argv[], len); //将源文件映射到缓冲区
char *psrc = mmap(NULL, len, PROT_READ, MAP_SHARED, srcfd, );
if (psrc == MAP_FAILED)
{
perror("mmap src err:");
exit();
} //将目标文件映射
char *pdst = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, dstfd, );
if (pdst == MAP_FAILED)
{
perror("mmap pdst err:");
exit();
}
//创建多个子进程
int i = ;
for (i = ; i < n; i++)
{
if (fork() == )
{
break;
}
}
//计算子进程需要拷贝的起点大小
int cpsize = len/n;
int mod = len%n;
//数据拷贝,memcpy
if (i < n)
{
//最后一个子进程
if (i == n-)
{
memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize+mod);
}
else
{
memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize);
}
}
else
{
for (i = ; i < n; i++)
{
//回收子线程
wait(NULL);
}
}
//释放映射区
if (munmap(psrc, len) < )
{
perror("munmap src err:");
exit();
} if (munmap(pdst, len) < )
{
perror("munmap dst err:");
exit();
} //关闭文件
close(srcfd);
close(dstfd); return ;
} 多进程文件拷贝

多进程文件拷贝

Yuchuan_Linux_C 编程之十一 进程间通信的更多相关文章

  1. (十二) 一起学 Unix 环境高级编程 (APUE) 之 进程间通信(IPC)

    . . . . . 目录 (一) 一起学 Unix 环境高级编程 (APUE) 之 标准IO (二) 一起学 Unix 环境高级编程 (APUE) 之 文件 IO (三) 一起学 Unix 环境高级编 ...

  2. Unix网络编程--卷二:进程间通信

    Unix网络编程--卷二:进程间通信 本书是一部Unix网络编程的经典之作!进程间通信(IPC)几乎是所有Unix程序性能的关键,理解IPC也是理解如何开发不同主机网络应用程序的必要条件.本书从对Po ...

  3. 【7】python核心编程 第十一章-函数和函数式编程

    1.*函数(与方法)装饰器 装饰器背后的主要动机源自python 面向对象编程.装饰器是在函数调用之上的修饰.这些修饰 仅是当声明一个函数或者方法的时候,才会应用的额外调用. 装饰器的语法以@开头,接 ...

  4. 学习ASP.NET Core Razor 编程系列十一——把新字段更新到数据库

    学习ASP.NET Core Razor 编程系列目录 学习ASP.NET Core Razor 编程系列一 学习ASP.NET Core Razor 编程系列二——添加一个实体 学习ASP.NET ...

  5. Java并发编程(十一)-- Java中的锁详解

    上一章我们已经简要的介绍了Java中的一些锁,本章我们就详细的来说说这些锁. synchronized锁 synchronized锁是什么? synchronized是Java的一个关键字,它能够将代 ...

  6. C#编程(十一)----------C#编程规范

    C#编程规范 1.要使一个代码块内的代码都同意缩进一个tab键长度 2.有下列情况下建议有换行 方法之间: 局部变量和它后边的语句之间: 方法内的功能逻辑部分之间: 3.{和}要单起一行 4.每行建议 ...

  7. Unix环境高级编程(十六)进程间通信

    进程间通信(IPC)是指能在两个进程间进行数据交换的机制.现代OS都对进程有保护机制,因此两个进程不能直接交换数据,必须通过一定机制来完成. IPC的机制的作用: (1)一个软件也能更容易跟第三方软件 ...

  8. c++ 网络编程(十一) LINUX下 初步制作基于HTTP的WEB服务器

    原文作者:aircraft 原文链接:https://www.cnblogs.com/DOMLX/p/9663028.html HTTP概要 理解Web服务器端: 编写HTTP(超文本传输协议)服务器 ...

  9. UNIX网络编程卷2进程间通信读书笔记(二)—管道 (1)

    一.管道 管道的名称很形象,它就像是一个水管,我们从一端到水然后水从令一端流出.不同的是这里说的管道的两边都是进程.从一端往管道里写数据,其它进程可以从管道的另一端的把数据读出,从而实现了进程间通信的 ...

随机推荐

  1. Hexo 下 Markdown 的配置与学习

    本篇 更换 Hexo 下的 Markdown 渲染插件 学习 Markdown 基本语法 ✎更换 Markdown 渲染插件 ✎原因 Hexo 内置的默认渲染插件是 hexo-renderer-mar ...

  2. ROS中的日志(log)消息

    学会使用日志(log)系统,做ROS大型项目的主治医生 通过显示进程的运行状态是好的习惯,但需要确定这样做不会影响到软件的运行效率和输出的清晰度.ROS 日志 (log) 系统的功能就是让进程生成一些 ...

  3. pytho语法基础-预备知识

    ############################################ """ 简述解释型和编译型编程语言? 解释型语言:可以直接运行,逐条翻译逐条运行 ...

  4. Leaflet,OpenLayers3加载ArcGIS切片(png格式,Exploded松散型)

    需求 做了一个简单的WebGIS应用,不想因为加载切片就安装一台GIS服务器.于是想直接访问图片的方式来加载地图. 需解决的问题 leafletjs目前是不能够直接加载ArcGIS服务切片的,但可以借 ...

  5. phpcms数组处理后键值插入(php自带库函数)和自己处理办法比较。

    phpcms处理: public function insert($data, $table, $return_insert_id = false, $replace = false) {  if(! ...

  6. UFT安装目录简单介绍

    1.在安装的help目录下可查看UFT相关的文档 2.在samples/filght/app目录下可看到UFT自带的用作测试的软件

  7. 3DMAX卸载/完美解决安装失败/如何彻底卸载清除干净3DMAX各种残留注册表和文件的方法

    在卸载3dmax重装3dmax时发现安装失败,提示是已安装3dmax或安装失败.这是因为上一次卸载3dmax没有清理干净,系统会误认为已经安装3dmax了.有的同学是新装的系统也会出现3dmax安装失 ...

  8. python 写个冒泡排序吧

    冒泡排序 介绍: 冒泡排序(Bubble Sort,台湾译为:泡沫排序或气泡排序)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作 ...

  9. Nginx for windows 访问路径包含中文

    转载自http://blog.csdn.net/five824/article/details/48261213 Nginx for windows 访问路径包含中文 原创 2015年09月07日 0 ...

  10. 转:ZABBIX监控H3C设备的CPU和内存使用率

      由于最近监控的H3C路由器经常出现死机现象,SNMP获取不到数据,后面检查发现是CPU使用率过高,直接导致无法处理SNMP请求,所以需求来了,怎样通过SNMP监控H3C路由器的CPU和内存使用率? ...