进程通讯fifo

最新推荐文章于 2021-11-14 23:02:45 发布
最新推荐文章于 2021-11-14 23:02:45 发布
阅读量281 收藏
点赞数
分类专栏： c例程

//转自陈颢文(老师)的blog

fifo1.c

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

//./a.out fifoname
int main(int argc, const char *argv[])
{
	int fd = 0;
	if(argc < 2)		
	{
		fprintf(stderr,"Usage : %s argv[1]",argv[0]);	
		exit(EXIT_FAILURE);
	}

	//创建有名管道文件
	if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	//打开有名管道文件
	//fd = open(argv[1],O_RDONLY);
	fd = open(argv[1],O_WRONLY | O_NONBLOCK);
//	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		perror("Fail to open");	
		exit(EXIT_FAILURE);
	}

	printf("open success!\n");

	close(fd);
	return 0;
}

fifo.c 

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

//./a.out fifoname
int main(int argc, const char *argv[])
{
	int fd = 0;
	if(argc < 2)		
	{
		fprintf(stderr,"Usage : %s argv[1]",argv[0]);	
		exit(EXIT_FAILURE);
	}

	//创建有名管道文件
	if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	//打开管道文件
	//fd = open(argv[1],O_RDONLY);
	fd = open(argv[1],O_WRONLY);
	if(fd < 0)
	{
		perror("Fail to open");	
		exit(EXIT_FAILURE);
	}

	printf("open success!\n");

	close(fd);
	return 0;
}
fifo2.c 

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

//./a.out fifoname
int main(int argc, const char *argv[])
{
	int fd = 0;
	int count = 0;
	int n = 0;
	char buf[1024] = {0};
	char *string = "hello"; 
	int i = 0;
	if(argc < 2)		
	{
		fprintf(stderr,"Usage : %s argv[1]",argv[0]);	
		exit(EXIT_FAILURE);
	}
	//创建有名管道文件
	if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	//打开有名管道文件
	//fd = open(argv[1],O_RDONLY);
	//fd = open(argv[1],O_WRONLY);
	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		perror("Fail to open");	
		exit(EXIT_FAILURE);
	}

	printf("open success!\n");

	//把数据写到管道文件中
	write(fd,string,strlen(string));

	n = read(fd,buf,sizeof(buf));

	printf("Read %d bytes : %s\n",n,buf);
	close(fd);
	return 0;
}
==================================
read_fifo.c 
#include <errno.h>
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

void do_read(int fd)
{
	char buf[1024] = {0};
	int n = 0;

	while(1)
	{
		memset(buf,0,sizeof(buf));
		n = read(fd,buf,sizeof(buf));
		if(n == 0)
			break;
		printf("read %d bytes : %s\n",n,buf);
	}
	return ;
}
//./a.out fifoname
int main(int argc, const char *argv[])
{
	int fd = 0;
	char buf[1024] = {0};
	int n = 0;
	if(argc < 2)		
	{
		fprintf(stderr,"Usage : %s argv[1]",argv[0]);	
		exit(EXIT_FAILURE);
	}
	//创建有名管道文件
	if((mkfifo(argv[1],0666)) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	//打开有名管道文件
	fd = open(argv[1],O_RDONLY);
	if(fd < 0)
	{
		perror("Fail to open");	
		exit(EXIT_FAILURE);
	}

	printf("open for read success!\n");

	do_read(fd);

	close(fd);
	return 0;
}
write_fifo.c 
#include <errno.h>
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h> 

void do_write(int fd)
{
	char buf[1024] = {0};
	int n = 0;
	while(1)
	{
		printf(">");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf) - 1] = '\0';

		if(strncmp(buf,"quit",4) == 0)
			break;
		n = write(fd,buf,strlen(buf));
		printf("write %d bytes is success\n",n);
	}
	 
	return ;
}

//./a.out fifoname
int main(int argc, const char *argv[])
{
	int fd = 0;
	int count = 0;
	int n = 0;
	char buf[1024] = {0};
	if(argc < 2)		
	{
		fprintf(stderr,"Usage : %s argv[1]",argv[0]);	
		exit(EXIT_FAILURE);
	}


	//创建有名管道文件
	if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	//打开有名管道文件
	fd = open(argv[1],O_WRONLY);
	if(fd < 0)
	{
		perror("Fail to open");	
		exit(EXIT_FAILURE);
	}

	printf("open for write success!\n");


	do_write(fd);
	close(fd);
	exit(EXIT_SUCCESS);
}

==============================================

talk

A.c

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

void do_read(int fd)
{
	char buf[1024] = {0};
	int n = 0;

	while(1)
	{
		memset(buf,0,sizeof(buf));
		n = read(fd,buf,sizeof(buf));
		if(n == 0)
			break;
		printf("read %d bytes : %s\n",n,buf);
	}

	exit(EXIT_SUCCESS);
}

void do_write(int fd)
{
	char buf[1024] = {0};
	int n = 0;
	while(1)
	{
		printf(">");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf) - 1] = '\0';

		if(strncmp(buf,"quit",4) == 0)
			break;
		n = write(fd,buf,strlen(buf));
		printf("write %d bytes is success\n",n);
	}
	 
	exit(EXIT_SUCCESS);
}
//./a.out fifoname
int main(int argc, const char *argv[])
{
	int fd1 = 0,fd2 = 0;
	char buf[1024] = {0};
	int n = 0;
	pid_t pid = 0;
	if(argc < 3)		
	{
		fprintf(stderr,"Usage : %s argv[1]",argv[0]);	
		exit(EXIT_FAILURE);
	}
	//创建有名管道文件
	if((mkfifo(argv[1],0666)) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	if((mkfifo(argv[2],0666)) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	pid = fork();
	if(pid < 0)
	{
		perror("Fail to fork");	
		exit(EXIT_FAILURE);
	}else if(pid > 0){
	
		//打开有名管道文件
		fd1 = open(argv[1],O_WRONLY);
		if(fd1 < 0)
		{
			perror("Fail to open");	
			exit(EXIT_FAILURE);
		}
		do_write(fd1);
		wait(NULL);
	}else if(pid == 0){
	
		fd2 = open(argv[2],O_RDONLY);
		if(fd2 < 0)
		{
			perror("Fail to open");	
			exit(EXIT_FAILURE);
		}

		do_read(fd2);
	}
	close(fd1);
	close(fd2);
	return 0;
}

b.c 

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

void do_read(int fd)
{
	char buf[1024] = {0};
	int n = 0;

	while(1)
	{
		memset(buf,0,sizeof(buf));
		n = read(fd,buf,sizeof(buf));
		if(n == 0)
			break;
		printf("read %d bytes : %s\n",n,buf);
	}
	exit(EXIT_SUCCESS);
}

void do_write(int fd)
{
	char buf[1024] = {0};
	int n = 0;
	while(1)
	{
		printf(">");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf) - 1] = '\0';

		if(strncmp(buf,"quit",4) == 0)
			break;
		n = write(fd,buf,strlen(buf));
		printf("write %d bytes is success\n",n);
	}
	 
	exit(EXIT_SUCCESS);
}
//./a.out fifoname
int main(int argc, const char *argv[])
{
	int fd1 = 0,fd2 = 0;
	char buf[1024] = {0};
	int n = 0;
	pid_t pid = 0;
	if(argc < 3)		
	{
		fprintf(stderr,"Usage : %s argv[1]",argv[0]);	
		exit(EXIT_FAILURE);
	}
	//创建有名管道文件
	if((mkfifo(argv[1],0666)) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	if((mkfifo(argv[2],0666)) < 0 && errno != EEXIST)
	{
		perror("Fail to create mkfifo");
		exit(EXIT_FAILURE);
	}

	pid = fork();
	if(pid < 0)
	{
		perror("Fail to fork");	
		exit(EXIT_FAILURE);
	}else if(pid > 0){
	
		//打开有名管道文件
		fd1 = open(argv[2],O_WRONLY);
		if(fd1 < 0)
		{
			perror("Fail to open");	
			exit(EXIT_FAILURE);
		}

		do_write(fd1);
		wait(NULL);
	}else if(pid == 0){
	
		fd2 = open(argv[1],O_RDONLY);
		if(fd2 < 0)
		{
			perror("Fail to open");	
			exit(EXIT_FAILURE);
		}

		do_read(fd2);
	}

	close(fd1);
	close(fd2);
	return 0;
}
test.c 

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int *p = NULL;

	*p = 10;
	printf("*p : %d\n",*p);
	return 0;
}

hello.c 

#include <stdio.h>

int main(int argc, const char *argv[])
{
	printf("hello world\n");	
	return 0;
}



paul123456789io
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程间的通讯demo——fifo
03-12
进程间的通讯demo——fifo，线程间通过队列fifo来进行通信
进程间通讯简介1
08-03
并且，管道的两端进程必须为相关进程相关进程可以简单的解成”同一个家族面儿的两个进程“，比如兄弟进程、父子进程、爷孙进程等等FIFO
的功能和管道非常类似，其最大
linux进程通信
zhaopengvv的博客
11-14 550
IPC (interProcess Communication) 进程间通信，通过内核提供的缓冲区，进行数据的交换机制。 IPC通信的几种方式： pipe 管道 最简单 fifo 有名管道 mmap 文件映射共享IO， 速度最快 本地socket最稳定 信号 携带的信号量最小 共享内存 消息队列 1. 管道pipe 管道通信优劣： 优点：简单，相比信号和套接字实现进程通信简单很多 缺点：1. 只能单向通信（半双工），双向通信需要建立两个管道？2. 只能用于父子、兄弟（有共同祖先）进程之间的通信。
linux进程有名管道,linux进程通信管理之：命名管道
weixin_39647458的博客
04-28 94
管道应用的一个重大限制就是它没有名字，因此，只能用于具有亲缘关系的进程间的通信，在有名管道(Named Pipe或FIFO)提出后，该限制得到了克服，FIFO不同于管道之处在于它提供了一个路径名与之关联，以FIFO的文件形式存在与文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，彼此之间就能进行通信。一个比较好的命名管道例子：下面这个例子使用FIFO进行进程间的通...
Linux有名管道编程
小水晶的专栏
03-16 4735
有名管道可以用于任何两个程序间通信，因为有名字可引用。注意管道都是单向的，因此双方通信需要两个管道。下面分别是这两个程序代码,同样是Lucy先运行,然后是Peter。fifoLucy.c#include#include#include#include#include#include#include#includeint main(){ char write_fifo_name[
FIFO（命名管道）
luciusvorenus
03-30 1918
FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间。但通过FIFO，不相关的进程也能交换数据。FIFO是Linux基础文件类型中的一种（p,管道文件）。但FIFO文件在磁盘上没有数据块，仅仅用来标识内核中一条通道。各进程可以打开这个文件进行read/write，实际上是在读写内核通道，这样就实现了进程间通信。另外，使用统一fifo文件，可以有多个读端和...
进程间通信（二）：使用命名管道fifo实现非血缘关系进程的通信
Blank_Shen的博客
06-20 985
一、命名管道fifo特点 命名管道fifo可用于无血缘关系的进程间通信 创建方式有两种： 1）mkfifo命令 2）mkfifo函数，函数原型如下 int mkfifo(const char *pathname, mode_t mode); 读端打开：open(fifoname, O_RDONLY) 写端打开：open(fifoname, O_WRONLY) 二、无血缘关系的进程间通信 1.写端 #include <stdio.h> #include <fcntl.h> #inc
linux进程通讯演示代码.rar_linux 进程通讯_syllablex7w
09-21
基于linux的进程通讯程序，包括FIFO,PIPE,SHAREMEM,signal等
Linux进程间通讯
02-02
IPC基本概念，无名管道(pipe)概念与编程，有名管道(fifo)概念与编程，信号概念与编程，定时器
进程间通讯（两个应用程序如何通讯）C#源代码.rar
06-18
缺点：必须有一个通讯双方共享的一个逻辑消息队列（ UNIX的PIPE，FIFO及IPC消息传递机制都属于这种形式），使用时消息发送者约定写方式打开信箱,消息接受者约定读方式打开信箱或同时读写打开。 优点：很容易建立...
2fifo有名管道
涂作权的博客
09-20 1162
 1fifo有名管道 创建一个有名管道，fifo 2.fifo依赖的头文件 #include #include 函数声明 int mkfifo(const char *pathname, mode_tmode); 3.fifo的写端应用 #include #include #include
linux之通过FIFO完成两个非血缘关系进程间的通信
发如雪
07-31 567
1.FIFO 常被称为命名管道,以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间。但通过 FIFO,不相关的进程也能交换数据。 2.FIFO 是 Linux 基础文件类型中的一种。但,FIFO 文件在磁盘上没有数据块,仅仅用来标识内核中一条通道。各进程可以打开这个文件进行 read/write,实际上是在读写内核通道,这样就实现了进程间通信。 3.创建方式: a.命令:mkfifo 管道名 b.库函数:int mkfifo(const char ...
Eclipse 打开时提示fail to create JVM 问题
javaqun的博客
10-27 822
这一般应是内存不够用所致，解决方法参考如下: 找到eclipse目录下的eclipse.ini，可以看到如下内容： -startup plugins/org.eclipse.equinox.launcher_1.1.0.v20100507.jar --launcher.library plugins/org.eclipse.equinox.launcher.win32.win32.
进程间通信--管道
一起摇摆_xianggy的专栏
05-11 557
转自：http://blog.chinaunix.net/uid-26833883-id-3227144.html 前面我们学习了一下进程，我们知道多，进程间的地址空间相对独立。进程与进程间不能像线程间通过全局变量通信。 如果想进程间通信，就需要其他机制。          常用的进程间通信方式有这几种 A.传统的进程间通信方式 无名管道(pipe
超爽的抽屉效果.zip
04-19
android 源码学习. 资料部分来源于合法的互联网渠道收集和整理，供大家学习参考与交流。本人不对所涉及的版权问题或内容负法律责任。如有侵权，请通知本人删除。感谢CSDN官方提供大家交流的平台
关于学习C语言时写的代码.zip
04-19
C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenneth Lane Thompson）设计的B语言为基础发展而来，在它的主体设计完成后，汤普森和里奇用它完全重写了UNIX，且随着UNIX的发展，c语言也得到了不断的完善。为了利于C语言的全面推广，许多专家学者和硬件厂商联合组成了C语言标准委员会，并在之后的1989年，诞生了第一个完备的C标准，简称“C89”，也就是“ANSI C”，截至2020年，最新的C语言标准为2018年6月发布的“C18”。 [5] C语言之所以命名为C，是因为C语言源自Ken Thompson发明的B语言，而B语言则源自BCPL语言。 1967年，剑桥大学的Martin Richards对CPL语言进行了简化，于是产生了BCPL（Basic Combined Programming Language）语言。
机械臂论文.doc
最新发布
04-19
机械臂论文.doc
S7200 and WINCC flexible.doc
04-19
S7200 and WINCC flexible.doc
freertos进程间通讯方式
08-15
消息队列遵循FIFO原则，即先进先出。在FreeRTOS中，可以使用队列集的结构来管理外设多的情况下的消息队列。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值