Linux 进程通信 2019.1.7（pipe，fifo，mmap，匿名映射）

最新推荐文章于 2022-11-23 16:45:17 发布
最新推荐文章于 2022-11-23 16:45:17 发布
阅读量467 收藏 2
点赞数 2
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/85958032
版权

ipc（进程间通信）的概念

interprocess communication：进程间通信——Linux通过内核给你提供了一块缓冲区，使得进程实现通信。

 

IPC通信的方式

  1. pipe 管道——最简单
  2. fifo 有名管道
  3. mmap 文件映射共享IO——速度最快（原理：在内存开辟一片缓冲区，把文件映射到内存上，你直接去操作内存就可以了）
  4. 本地socket 最稳定
  5. 信号 携带信息量最小的
  6. 共享内存 开辟一块内存区域，大家都能访问，一个进程退出之后，这块内存还会给你保留下来，后来者还可以继续使用
  7. 消息队列

 

 

管道——半双工通信

（带fd的参数一般都是指文件描述符）

一端读，一端写

一个进程写，一个进程读，他俩只能是父子进程。

 

常见的通信方式

单工（广播）、半双工（对讲机）、全双工（打电话）

 

管道通信使用举例

管道函数：

int pipe(int pipefd[2]);

  1. pipefd 读写文件描述符 0 代表 读， 1 代表 写
  2. 返回值 成功返回 0， 失败返回  -1.

调用完  就相当于在内核开辟了一块缓冲区。

 

父子进程间通信

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

int main() {
	//创建文件描述符
	int fd[2];
	//创建管道
	pipe(fd);
	pid_t pid = fork();

	if (pid == 0) {
		//son
		sleep(3);
		write(fd[1], "hello", 5);
	}
	else if (pid > 0) {
		//father
		//现有缓冲区，然后才能读
		char buf[12] = { 0 };
		//阻塞等待，哪怕子进程sleep了，也要等
		int ret = read(fd[0], buf, sizeof(buf));
		//说明读到了
		if (ret > 0) {
			write(STDOUT_FILEND, buf, ret);
		}
	}
	return 0;
}

运行结果

 

父子进程实现pipe通信，实现ps aux |  grep bash 功能

由于父子进程都掌握着管道（pipe）的读写两端，因此有如下结构示意图

出现问题的测试代码：（我们希望子进程写入，父进程读取）

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

int main() {
	//创建文件描述符
	int fd[2];
	//创建管道
	pipe(fd);
	pid_t pid = fork();

	if (pid == 0) {
		//son
		//son执行ps命令
		//1、先重定向
		dup2(fd[1], STDOUT_FILENO);//标准输出重定向
		//2、execlp  NULL是哨兵，告诉命令，后面不会再有参数输入了
		execlp("ps"."ps"."aux", NULL);
	}
	else if (pid > 0) {
		//father
		//1、先重定向
		dup2(fd[0], STDIN_FILENO);//标准输出重定向
		//2、execlp  NULL是哨兵，告诉命令，后面不会再有参数输入了
		execlp("grep"."grep"."bash", NULL);
	}
	return 0;
}

出现的问题：

子进程变成僵尸进程，父进程执行grep之后一直在等待输入。

 

分析原因：

grep命令的特性：等待标准输入，如果你输入的正确，则给你一个反馈。阻塞等待，因为grep一直认为还有输入，除非是输入端的进程放弃了写入的机会。grep阻塞等待示例，如图所示

 

上面代码出现问题，是因为虽然子进程死去了，但是父进程还掌握着管道写入端的句柄，所以grep一直认为还会有输入，虽然此时读写两端都是父进程掌握。所以我们需要在代码中关闭子进程的读端，以及父进程对于管道的写端。

//关闭 读端
close(fd[0]);

//关闭 写端
close(fd[1]);

在使用管道时，应该把读写两端都规划好。这样数据的流向才稳定。

 

修正之后的代码：

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

int main() {
	//创建文件描述符
	int fd[2];
	//创建管道
	pipe(fd);
	pid_t pid = fork();

	if (pid == 0) {
		//son
		//son执行ps命令
		//关闭 读端
		close(fd[0]);
		//1、先重定向
		dup2(fd[1], STDOUT_FILENO);//标准输出重定向
		//2、execlp  NULL是哨兵，告诉命令，后面不会再有参数输入了
		execlp("ps"."ps"."aux", NULL);
	}
	else if (pid > 0) {
		//father
		//关闭 写端
		close(fd[1]);
		//1、先重定向
		dup2(fd[0], STDIN_FILENO);//标准输出重定向
		//2、execlp  NULL是哨兵，告诉命令，后面不会再有参数输入了
		execlp("grep"."grep"."bash", NULL);
	}
	return 0;
}

运行结果

 

 

管道的读写行为分析

读管道

  • 写端全部关闭——read读到0，相当于读到文件末尾
  • 写端没有全部关闭
  1. 有数据——read读到数据
  2. 没有数据——read阻塞  fcntl 函数可以更改阻塞为非阻塞

写管道

  • 读端全部关闭——产生一个信号 SIGPIPE ，程序异常终止
  • 读端未全部关闭
  1. 管道已满——write阻塞
  2. 管道未满——write正常写入

 

 

测试代码

1、写端全部关闭——read读到0，相当于读到文件末尾

子进程关闭读端——子进程写入数据——子进程关闭写端——父进程关闭写端——父进程读取数据——读到0则说明读取完毕，输出“read over”

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

int main() {
	//创建文件描述符
	int fd[2];
	//创建管道
	pipe(fd);
	pid_t pid = fork();

	if (pid == 0) {
		//son
		sleep(3);
		//关闭 读端
		close(fd[0]);
		//写入数据
		write(fd[1], "hello", 5);
		//关闭写端
		close(fd[1]);
		//关闭读写之后，先别去死
		while (1) {
			sleep(1);
		}
	}
	else if (pid > 0) {
		//father
		char buf[12] = { 0 };
		//关闭写端
		close(fd[1]);
		while (1) {
			//阻塞等待，读取动作
			int ret = read(fd[0], buf, sizeof(buf));
			//读取完毕
			if (ret == 0) {
				printf("read over\n");
			}
		}
	}
	return 0;
}

运行结果（正常退出）：

 

2、读端全部关闭——产生一个信号 SIGPIPE ，程序异常终止

父进程关闭读写——子进程关闭读端——写入数据——子进程异常终止，产生信号SIGPIPE——父进程获取子进程的死亡信息

#include<stdio.h>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/types.h>

int main() {
	//创建文件描述符
	int fd[2];
	//创建管道
	pipe(fd);
	pid_t pid = fork();

	if (pid == 0) {
		//son
		sleep(3);
		//关闭 读端
		close(fd[0]);
		//写入数据
		write(fd[1], "hello", 5);
		//关闭写端
		close(fd[1]);
		//关闭读写之后，先别去死
		while (1) {
			sleep(1);
		}
	}
	else if (pid > 0) {
		//father
		//关闭写端
		close(fd[1]);
		//关闭 读端
		close(fd[0]);
		//获取子进程死亡信息
		int status;
		wait(&status);
		if (WIFSIGNALED(status)) {
			printf("killed by %d\n", WTERMSIG(status));
		}
		while (1) {
			sleep(1);
		}
	}
	return 0;
}

运行结果：

 

 

 

实现兄弟间进程通信， ps aux | grep bash

 

 

 

 

管道的大小和优劣

使用命令查看当前系统中创建管道文件所对应的内核缓冲区大小

ulimit -a

函数fpathconf

 

优点

  • 简单

缺点

  • 只能有血缘关系之间的进程通信
  • 父子进程单方向通信，如果需要双向通信，需要创建多个管道。

 

 

 

FIFO通信

有名管道，实现无血缘关系进程的通信

  • 创建一个管道的伪文件
  1. mkfifo myfifo 命令创建
  2. 也可以用函数int mkfifo(const char *pathname, mode_t mode);
  • 内核会为fifo文件开辟一块缓冲区，操作fifo文件，可以操作缓冲区，实现进程间通信——实际上就是文件读写。
  • open函数的注意事项：打开fifo文件的时候，read端会阻塞等待write端open，write端同理，也会阻塞等待另外一端打开。

 

被mkfifo myfifo 命令创建出来的管道伪文件截图

 

写端示例

#include<stdio.h>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/types.h>
#include<fcntl.h>
#include<string.h>

int main(int argc, char *argv[]) {
	if (argc != 2) {
		//如果运行时没有输入文件名，则会报错
		printf("./a.out fifoname\n");
		return -1;
	}
	//当前目录中存在myfifo文件
	//打开fifo文件
	int fd = open(argv[1], O_WRONLY);
	//写
	char buf[256];
	int num = 1;
	while (1) {
		memset(buf, 0x00, sizeof(buf));
		sprintf(buf, "xiaoming%04d", num++);
		write(fd, buf, strlen(buf));
		sleep(1);
	}
	//关闭描述符
	close(fd);

	return 0;
}

 

读端示例

#include<stdio.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
#include<string.h>

int main(int argc, char *argv[]) {
	if (argc != 2) {
		//如果运行时没有输入文件名，则会报错
		printf("./a.out fifoname\n");
		return -1;
	}
	int fd = open(argv[1], O_RDONLY);

	char buf[256];
	int ret;
	while (1) {
		//循环读
		ret = read(fd, buf, sizeof(buf));
		if (ret > 0) {
			printf("read:%s\n", buf);
		}
	}

	//关闭描述符
	close(fd);
	return 0;
}

 

读端和写端中的open函数会阻塞，之后对端的open函数也打开了，他才会停止阻塞行为

 

 

 

 

mmap共享映射区

把文件中的某一段映射到内存上

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
  • addr 传地址，一般写NULL
  • length 映射区长度
  • prot 
  1. PROT_READ 可读
  2. PROT_WRITE 可写
  • flags
  1. MAP_SHARED 共享的，对内存的修改会影响到源文件
  2. MAP_PRIVATE 私有的
  • fd 文件描述符
  • offset 偏移量
  • 返回值
  1. 成功 返回 可用内存的首地址
  2. 失败 返回 MAP_FAILED

 

释放内存区

#include <sys/mman.h>
int munmap(void *addr, size_t length);
  • addr 传mmap返回值
  • length mmap创建的长度
  • 返回值

 

实例（MAP_SHARED的作用是，你修改了内存，会影响文件）

#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("men.txt", O_RDWR);
	//创建映射区
	char *mem=mmap(NULL, 8, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

	if(mem==MAP_FAILED){
		perror("mmap err");
		return -1;
	}

	//拷贝数据
	strcpy(mem, "hello");

	//释放mmap
	munmap(mem, 8);
	close(fd);
	return 0;
}

运行结果

因此可以用mmap来修改文件内容。

 

mmap九问：

 

问题一的测试：（因此不能改，否则会释放失败）

#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("men.txt", O_RDWR);
	//创建映射区
	char *mem=mmap(NULL, 8, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

	if(mem==MAP_FAILED){
		perror("mmap err");
		return -1;
	}

	//拷贝数据
	strcpy(mem, "hello");
	mem++;
	//如果释放失败
	if (munmmap(mem, 8) < 0) {
		perror("munmmap err");
	}
	close(fd);
	return 0;
}

运行结果

 

问题二的测试：

#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("men.txt", O_RDWR);
	//创建映射区
	char *mem=mmap(NULL, 8, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

	if(mem==MAP_FAILED){
		perror("mmap err");
		return -1;
	}

	//拷贝数据
	strcpy(mem, "hellollllllllllll");

	//释放内存
	munmmap(mem, 8);
	close(fd);
	return 0;
}

文件的大小对映射区操作有影响，尽量避免。

 

char *mem=mmap(NULL, 8, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 1000000000);

offset必须是4k的整数倍。

 

没有。因为mmap之后，通道就打通了，文件就没用了。

 

int fd=open("men.txt", O_RDWR|O_TRUNC, 0664);//创建并截断文件

      bus error//总线错误

可以，但是文件大小不能为0.

 

不可以

 

不可以。SHARED的时候，映射区的权限要小于等于open文件的权限。

 

 

 

mmap实现父子进程通信

#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,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    //int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);
    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    // fork子进程
    pid_t pid = fork();

    // 父进程和子进程交替修改数据
    if(pid == 0 ){
        //son 
        *mem = 100;
        printf("child,*mem = %d\n",*mem);
        sleep(3);
        printf("child,*mem = %d\n",*mem);
    }
    else if(pid > 0){
        //parent
        sleep(1);
        printf("parent,*mem=%d\n",*mem);
        *mem = 1001;
        printf("parent,*mem=%d\n",*mem);
		//回收子进程
        wait(NULL);
    }

	//释放内存
    munmap(mem,4);
    close(fd);
    return 0;
}

运行结果

 

将上面的注释去掉，改成

//int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);

运行结果

父进程并没有读到子进程的数据，子进程也没有读到父进程改的数据。

因此，

 

 

匿名映射——避免打开文件的操作（上面的例子都有调用open函数）

 int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,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,4,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);

    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }

    pid_t pid = fork();

    if(pid == 0 ){
        //son 
        *mem = 101;
        printf("child,*mem=%d\n",*mem);
        sleep(3);
        printf("child,*mem=%d\n",*mem);
    }else if(pid > 0){
        //parent 
        sleep(1);
        printf("parent,*mem=%d\n",*mem);
        *mem = 10001;
        printf("parent,*mem=%d\n",*mem);
        wait(NULL);
    }

    munmap(mem,4);
    return 0;
}

运行结果

 

注意：有的Unix系统中没有MAP_ANON，ANONYMOUS这两个宏。此时该怎么办？

此时用这个

/dev/zero 是一个聚宝盆，无限大，用它做匿名映射，你想取多大都可以。

小技巧——快速把一个文件头几行的数据重定向到另一个文件中

 

 

mmap实现无血缘进程通信

写端

#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[20];
}Student;

int main(int argc,char *argv[])
{
    if(argc != 2){
        printf("./a.out filename\n");
        return -1;
    }
    
    // 1. open file 
    int fd = open(argv[1],O_RDWR|O_CREAT|O_TRUNC,0666);
	//结构体的大小
    int length = sizeof(Student);
	//将文件大小改变为参数length指定的大小，
	//如果原来的文件大小比参数length大，则超过的部分会被删除，
	//如果原来的文件大小比参数length小，则文件将被扩展
    ftruncate(fd,length);

    // 2. mmap
    Student * stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    //如果不判断是否出错，会死的很难看
    if(stu == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    int num = 1;

    // 3. 修改内存数据
    while(1){
        stu->sid = num;
        sprintf(stu->sname,"xiaoming-%03d",num++);
        sleep(1);//相当于每隔1s修改一次映射区的内容
    }
    // 4. 释放映射区和关闭文件描述符
    munmap(stu,length);
    close(fd);

    return 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>

typedef struct _Student{
    int sid;
    char sname[20];
}Student;

int main(int argc,char *argv[])
{
    //open file 
    int fd = open(argv[1],O_RDWR);
    //mmap 
    int length = sizeof(Student);
    Student *stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(stu == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    //read data 
    while(1){
        printf("sid=%d,sname=%s\n",stu->sid,stu->sname);
        sleep(1);
    }
    //close and munmap 
    munmap(stu,length);
    close(fd);
    return 0;
}

运行结果：

再开一个读的

王小闹儿
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统 mmap 存储映射
tugouxp的专栏
04-23 1656
括号中表示预期行为，括号外部的表示在LINUX系统中的实际行为，比如组合SHARED/EXEC的读行为，对于一个可执行的共享地址来说，没有给与PROT_READ属性，预期当然不可读，但是由于CPU执行上面的代码，必须要进行读操作，而实际的硬件架构和及并没有区分执行读和其它方式的读，所以，实际上对于这样的内存，仍然是可读的。从上图中可以看到，这段匿名区域（可能是MMAP区域，现在的MALLOC都用MMAP实现）地址是向下增长的，像栈一样，就像前面提到的第二种情况，这是在哪里控制的呢？
匿名映射
luciusvorenus
03-31 1840
通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定：MAP_ANONYM...
Linux内存映射函数mmap与匿名内存块
InternalsOf
11-23 1300
memory-mapped io可以将文件映射到内存中的buffer，当我们从buffer读写数据时，其实操作的是对应文件中的数据。这样可以达到不使用READ/WRITE的IO操作。 mmap也可以直接映射匿名内存块，无需提供文件fd，直接申请一块内存给当前进程使用，也可以选择继承给子进程。
mmap匿名映射
热门推荐
SweeNeil
11-02 1万+
一、原理 mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进...
匿名映射区
xunfengdumo的博客
06-10 224
不用打开文件来建立映射区 include<stdio.h> #include<fcntl.h> #include<unistd.h> #include<string.h> #include<stdlib.h> #include<sys/mman.h> int var =100; int main(void) { int *p; pid_t pid; //MAP_ANON 这个宏 可以
Linux进程间通信.zip
07-02
本资料包“Linux进程间通信.zip”着重介绍了几种主要的IPC机制，包括fifo（命名管道）、pipe（匿名管道）以及mmap（内存映射），并预告了后续将涉及的消息队列和信号。下面我们将详细探讨这些通信方式。 1. **fifo...
C++进程间通信源码.zip
04-03
在C++编程中，进程间通信（Inter-Process Communication, IPC）是一种技术，允许不同的进程之间交换数据，协同完成任务。这里的"C++进程间通信源码.zip"包含了一些示例代码，帮助开发者理解和实践C++中的IPC技术。...
9. Linux驱动开发-视频广告机开发、Linux进程编程介绍.pdf
最新发布
07-10
3. **进程通信** - **管道（Pipe）**：分为无名管道和命名管道，用于具有亲缘关系的进程间通信。无名管道通过文件描述符进行数据传输，具有先进先出（FIFO）特性。 - **消息队列**：提供了一种存储和传递消息的...
Linux下进程通信的八种方法.docx
04-20
在Linux操作系统中，进程通信是实现多进程协作和数据交换的关键技术。本文将详细阐述Linux下的八种进程通信方法，帮助读者理解并掌握这些技术。 1. **管道(Pipe)**： 管道是一种半双工通信方式，允许一个进程...
linux下进程通信实例
12-10
在Linux操作系统中，进程通信（Process Communication）是多个并发运行的程序之间交换信息的方式。这一概念对于理解操作系统内部的工作机制以及编写多线程、多进程应用程序至关重要。在本实例中，我们将探讨几种常见...
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
07-07
说明：编译时加上参数 -lrt -lpthread 要不然找不到库文件
分析匿名页(anonymous_page)映射
半月旋空
04-28 2653
接着上一次malloc（探秘malloc是如何申请内存的）的dump信息继续分析。 -006|do_anonymous_page(inline) | vma = 0xFFFFFFE314E27310 | tsk = 0xFFFFFFE300786640 | entry = (pte = 0x00E800026F281F53) -006|handle_pte_fau...
linux内存管理笔记(三十四）----匿名映射
奇小葩
01-03 5829
匿名内存是用户空间的概念，不涉及内核态内存。匿名内存的概念是指一段虚拟内存映射是否与之相关联的对象，如果没有关联对象就称为匿名的。本章就主要学习缺页异常的匿名映射，其中涉及到以下内容 匿名映射的概念 匿名映射的流程 1. 概念 由于应用程序申请内存后，内核分配了虚拟内存，当访问所需要的的内存时候，才会分配实际的物理内存，才能节省实际内存的使用。我们来看看匿名映射和文件映射的区别 匿名页面，是指那些没有关联到文件页，如进程堆、栈、数据段和任务已修改的共享库等，不是以文件形式存在，因此无法和磁盘文件交换
Linux系统编程 - 22. 匿名映射
我思故我在！
11-20 291
字符设备：伪文件。 /dev/null，外号叫无底洞，你可以向它输出任何数据，它通吃，并且不会撑着！ /dev/zero,是一个输入设备，你可你用它来初始化文件。 /dev/null------它是空设备，也称为位桶（bit bucket）。任何写入它的输出都会被抛弃。如果不想让消息以标准输出显示或写入文件，那么可以将消息重定向到位桶。 /dev/zero------该设备无穷尽地提供0，可以使用任何你需要的数目——设备提供的要多的多。他可以用于向设备或文件写入字符串0。 ...
Linux学习之系统编程篇：创建匿名映射区（只适用于有血缘关系）
weixin_42374938的博客
07-21 119
在之前的文章中我们讲过创建“有名映射区”：即创建之前一定要先打开文件。 本处是不需要先创建文件。 方法：与创建”有名映射区“相比 第2参数（映射区长度）：因为这个参数通常为文件大小，而不创建文件，只能自己指定。 第4参数（标志位参数） 多一个宏 MAP_ANON。 第5参数（文件描述符） 传 -1 表示不用。 int len = 1024; void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
Linux系统编程---5（共享存储映射，存储映射I/O，mmap函数，父子进程间通信，匿名映射）
LXY的博客
08-14 643
共享存储映射 文件进程间通信 使用文件也可以完成 IPC，理论依据是，fork 后，父子进程共享文件描述符。也就共享打开的文件。 编程：父子进程共享打开的文件。借助文件进行进程间通信。 测试代码 /* * * 父子进程共享打开的文件描述符----使用文件完成进程间通信 * */ #include<stdio.h> #include<unistd.h> #inclu...
进程间通信pipe、fifo、mmap应用
sinat_22706095的博客
01-19 373
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;unistd.h&gt; #include &lt;string.h&gt; #include &lt;iostream&gt; #include &lt;sys/types.h&gt; #include &lt;sys/wait.h&gt; using namesp
25.mmap创建非匿名的内存映射区
Disappear_XueChao的博客
07-05 334
1.必须有一个文件2.文件里的数据什么时候有用：　(1)执行mmap时，将文件里的数据映射到映射区　(2)进程间通信：文件里的数据是没有用的，进程间操作的是映射区的数据...
4、进程间通信（pipe、fifo、共享内存（shm、mmap函数实现代码））（linux系统编程）
伍粟的博客
04-25 516
进程间通信： 任何一个进程的全局变量在另一个进程中都看不到， 所以进程和进程之间不能相互访问，要交换数据必须通过内核， 在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区， 进程2再从内核缓冲区把数据读走， 内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。 进程间通信的方式: 在进程间完成数据传递需要借助操作系统提供特殊的方法， 进程间的七大通信方式 signal、file、 pipe（管道（Pipe）及有名管道（named pipe）：就是pi
ARMLinux进程通信：命名管道FIFO示例解析
本文主要介绍了在嵌入式Linux环境下使用命名管道(FIFO)实现进程间通信的一个应用实例，以及ARMLinux的进程与进程调度的相关概念。 在嵌入式Linux中，进程间通信（IPC）是系统设计的关键部分，命名管道是一种简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值