分别用多进程和多线程的方式来使用fifo管道，实现通信

最新推荐文章于 2023-03-09 20:15:51 发布
最新推荐文章于 2023-03-09 20:15:51 发布
阅读量368 收藏
点赞数
文章标签： 算法 c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45576731/article/details/127892005
版权

使用多线程的方式使用fifo管道实现通信

A程序

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

char buf[128];

//fifo管道写端线程
void* fifo_w(void* arg)
{
	int res = 0;
	int fd_w = open("fifo",O_WRONLY);
	if(fd_w < 0)
	{
		perror("open");
		return NULL;
	}
	//printf("open fifo success\n");

	while(1)
	{
		//终端输入
		bzero(buf,sizeof(buf));
		printf("A进程说>>>\n");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1] = 0;

		res = write(fd_w,buf,sizeof(buf));
		if(res < 0)
		{
			perror("write");
			return NULL;
		}
		if(0 == strcmp(buf,"quit"))
		{
			printf("A写端退出\n");
			break;
		}
	}
	//关闭文件描述符并退出
	pthread_exit(NULL);
	close(fd_w);
}

//fifo1管道读端线程
void* fifo1_r(void* arg)
{
	int res = 0;
	//以只读的方式打开fifo1管道
	int fd_r = open("fifo1", O_RDONLY);
	if(fd_r < 0)
	{
		perror("open");
		return NULL;
	}
	//printf("open fifo1 success\n");

	while(1)
	{
		//从管道fifo1中读
		bzero(buf,sizeof(buf));
		res = read(fd_r,buf,sizeof(buf));
		if(res < 0)
		{
			perror("read");
			return NULL;
		}
		//写端关闭后read不阻塞，当数据读取完毕，直接返回0
		else if(0 == res)
		{
			printf("B写端退出\n");
			break;
		}
		printf("A进程接收到：%s\n",buf);
		if(0 == strcmp(buf,"quit"))
		{
			printf("B写端退出\n");
			break;
		}
	}
	pthread_exit(NULL);
	close(fd_r);
}


int main(int argc, const char *argv[])
{
	//重设文件权限掩码
	umask(0);

	//创建两个fifo管道,并排除文件已经存在的错误
	if(mkfifo("./fifo",0777) < 0 )
	{
		//	printf("errno = %d\n",errno);
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo create success\n");

	if(mkfifo("./fifo1", 0777) < 0)
	{
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo1 create success\n");

	//创建两个线程
	pthread_t tid1,tid2;
	if(pthread_create(&tid1,NULL,fifo_w,NULL) < 0)
	{
		perror("pthread_create");
		return -1;
	}
	if(pthread_create(&tid2,NULL,fifo1_r,NULL) <0)
	{
		perror("pthread_create");
		return -1;
	}
	//阻塞等待线程退出	
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	return 0;
}

B程序

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

char buf[128];

//fifo1管道写端线程
void* fifo1_w(void* arg)
{
	int res = 0;
	int fd_w = open("fifo1",O_WRONLY);
	if(fd_w < 0)
	{
		perror("open");
		return NULL;
	}
	//printf("open fifo1 success\n");

	while(1)
	{
		//终端输入
		bzero(buf,sizeof(buf));
		printf("B进程说>>>\n");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1] = 0;

		res = write(fd_w,buf,sizeof(buf));
		if(res < 0)
		{
			perror("write");
			return NULL;
		}
		if(0 == strcmp(buf,"quit"))
		{
			printf("B写端退出\n");
			break;
		}
	}
	//关闭文件描述符并退出
	pthread_exit(NULL);
	close(fd_w);
}

//fifo管道读端线程
void* fifo_r(void* arg)
{
	int res = 0;
	//以只读的方式打开fifo1管道
	int fd_r = open("fifo", O_RDONLY);
	if(fd_r < 0)
	{
		perror("open");
		return NULL;
	}
	//printf("open fifo success\n");

	while(1)
	{
		//从管道fifo中读
		bzero(buf,sizeof(buf));
		res = read(fd_r,buf,sizeof(buf));
		if(res < 0)
		{
			perror("read");
			return NULL;
		}
		//写端关闭后read不阻塞，当数据读取完毕，直接返回0
		else if(0 == res)
		{
			printf("A进程退出\n");
			break;
		}
		printf("B进程接收到：%s\n",buf);
		if(0 == strcmp(buf,"quit"))
		{
			printf("A写端退出\n");
			break;
		}
	}
	pthread_exit(NULL);
	close(fd_r);
}


int main(int argc, const char *argv[])
{
	//重设文件权限掩码
	umask(0);

	//创建两个fifo管道,并排除文件已经存在的错误
	if(mkfifo("./fifo",0777) < 0 )
	{
		//	printf("errno = %d\n",errno);
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo create success\n");

	if(mkfifo("./fifo1", 0777) < 0)
	{
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo1 create success\n");

	//创建两个线程
	pthread_t tid1,tid2;
	if(pthread_create(&tid1,NULL,fifo1_w,NULL) < 0)
	{
		perror("pthread_create");
		return -1;
	}
	if(pthread_create(&tid2,NULL,fifo_r,NULL) <0)
	{
		perror("pthread_create");
		return -1;
	}
	//阻塞等待线程退出	
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	return 0;
}

使用多进程的方式使用fifo管道实现通信，并加入使用信号回收僵尸进程的方法

A程序

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>

char buf[128];

//重定义用sighandler_t代表返回值为void有一个int类型的参数的函数指针
typedef void (*sighandler_t)(int);

//回收僵尸进程的任务
void recycle(int sig)
{
	while(waitpid(-1,NULL,WNOHANG)>0);
}


int main(int argc, const char *argv[])
{
	//重设文件权限掩码
	umask(0);
	//创建两个fifo管道，并排除文件已经存在的错误
	if(mkfifo("./fifo",0777) < 0 )
	{
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo create success\n");

	if(mkfifo("./fifo1", 0777) < 0)
	{
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo1 create success\n");

	//创建子进程
	pid_t pid = fork();
	if(pid > 0)
	{
		//捕获信号
		sighandler_t s = signal(SIGCHLD, recycle);
		if(SIG_ERR == s)
		{
			perror("signal");
			return -1;
		}
		int res = 0;
		//以只写的方式打开fifo管道
		int fd_w = open("fifo",O_WRONLY);
		if(fd_w < 0)
		{
			perror("open");
			return -1;
		}

		while(1)
		{
			//终端输入
			bzero(buf,sizeof(buf));
			printf("A进程说>>>\n");
			fgets(buf,sizeof(buf),stdin);
			buf[strlen(buf)-1] = 0;

			//写入数据到fifo管道
			res = write(fd_w,buf,sizeof(buf));
			if(res < 0)
			{
				perror("write");
				return -1;
			}
			if(0 == strcmp(buf,"quit"))
			{
				printf("A写端退出\n");
				break;
			}
		}
		//关闭文件描述符
		close(fd_w);
		//等待子进程退出
		wait(NULL);
		
	}
	else if(0 == pid)
	{
		int res = 0;
		int fd_r = open("fifo1", O_RDONLY);
		if(fd_r < 0)
		{
			perror("open");
			return -1;
		}

		while(1)
		{
			//从管道fifo1中读
			bzero(buf,sizeof(buf));
			res = read(fd_r,buf,sizeof(buf));
			if(res < 0)
			{
				perror("read");
				return -1;
			}
			else if(0 == res)
			{
				printf("B进程退出\n");
				break;
			}
			printf("A进程接收到：%s\n",buf);
			if(0 == strcmp(buf,"quit"))
			{
				printf("B写端退出\n");
				break;
			}
		}
		close(fd_r);
	}
	else
	{
		perror("fork");
		return -1;
	}

	return 0;
}

B进程

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

char buf[128];

//重定义用sighandler_t代表返回值为void有一个int类型的参数的函数指针
typedef void (*sighandler_t)(int);

//回收僵尸进程的任务
void recycle(int sig)
{
	while(waitpid(-1,NULL,WNOHANG)>0);
}

int main(int argc, const char *argv[])
{
	//回收僵尸进程的任务
	umask(0);

	//创建两个fifo管道，并排除文件已经存在的错误
	if(mkfifo("./fifo",0777) < 0 )
	{
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo create success\n");

	if(mkfifo("./fifo1", 0777) < 0)
	{
		if(17 != errno)
		{
			perror("mkfifo");
			return -1;
		}
	}
	else
		printf("fifo1 create success\n");

	//创建子进程
	pid_t pid = fork();
	if(pid > 0)
	{
		//捕获信号
		sighandler_t s = signal(SIGCHLD, recycle);
		if(SIG_ERR == s)
		{
			perror("signal");
			return -1;
		}
		int res = 0;
		//以只写的方式打开fifo1管道
		int fd_w = open("fifo1",O_WRONLY);
		if(fd_w < 0)
		{
			perror("open");
			return -1;
		}

		while(1)
		{
			//终端输入
			bzero(buf,sizeof(buf));
			printf("B进程说>>>\n");
			fgets(buf,sizeof(buf),stdin);
			buf[strlen(buf)-1] = 0;

			//写入数据到fifo1管道
			res = write(fd_w,buf,sizeof(buf));
			if(res < 0)
			{
				perror("write");
				return -1;
			}
			if(0 == strcmp(buf,"quit"))
			{
				printf("B写端退出\n");
				break;
			}
		}
		//关闭文件描述符
		close(fd_w);
		//等待子进程退出
		wait(NULL);
	}
	else if(0 == pid)
	{
		int res = 0;
		int fd_r = open("fifo", O_RDONLY);
		if(fd_r < 0)
		{
			perror("open");
			return -1;
		}

		while(1)
		{
			//从管道fifo中读
			bzero(buf,sizeof(buf));
			res = read(fd_r,buf,sizeof(buf));
			if(res < 0)
			{
				perror("read");
				return -1;
			}
			else if(0 == res)
			{
				printf("A进程退出\n");
				break;
			}
			printf("B进程接收到：%s\n",buf);
			if(0 == strcmp(buf,"quit"))
			{
				printf("A写端退出\n");
				break;
			}
		}
		close(fd_r);

	}
	else
	{
		perror("fork");
		return -1;
	}

	return 0;
}
J学生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
进程间的通讯demo——fifo
03-12
进程间的通讯demo——fifo，线程间通过队列fifo来进行通信
Linux 多任务编程——进程间通信：有名管道(FIFO)
Hamlee67的博客
11-22 319
命名管道的概述 无名管道，由于没有名字，只能用于亲缘关系的进程间通信（更多详情，请看《无名管道》）。为了克服这个缺点，提出了命名管道（FIFO），也叫有名管道、FIFO 文件。 命名管道（FIFO）不同于无名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，这样，即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通...
支持多线程的FIFO实现
mcupro的专栏
03-23 372
支持多线程的FIFO实现 #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <unistd.h> #include <pthread.h> #include "thread_safe_fifo.h" #define MAX_BIT 8 #define MAX_SIZE (1<<MAX_BIT) #define CH_SIZE 4..
Linux管道FIFO -- 通过管道实现进程之间通信实例
weixin_43354152的博客
09-28 608
进程之间管道通信实例，管道的基本概念
Linux进程间通信，IPC-FIFO管道
m0_69190774的博客
03-09 140
实际上，当我们调用mkfifo创建一个FIFO命名管道的时候，内核会为这个FIFO（伪）文件创建一个缓存区，当我们对FIFO文件进行open，read，write等文件I/O操作的时候就相当于操作这个缓存区，以此来实现进程间通信。
python多进程实现进程间通信实例
09-21
Python中的多进程编程是利用`multiprocessing`模块来实现的，这个模块允许我们创建和管理多个独立运行的进程。在Python的多线程环境中，由于全局解释器锁（GIL）的存在，多线程并不能充分利用多核CPU的优势，因此多...
FIFO.rar_FIFO移植_fifo vc 函数_同时读写_多个fifo_多线程FIFO
09-24
在多线程FIFO中，正确的同步至关重要，否则可能会导致数据丢失或者程序崩溃。 “多个fifo”意味着项目可能涉及到了管理多个独立的FIFO队列，每个队列可能服务于不同的目的或者线程。这种设计能够提高系统的并行性和...
p192 - p219 进程和线程之间的通信
最新发布
05-15
在Linux中，有很多种方式实现进程间通信，包括管道、信号量、消息队列、共享内存、套接字等。本文主要讨论的是管道，分为匿名管道和命名管道（FIFO）。 匿名管道是早期的进程间通信方式，它的创建基于内核中的一个...
第二次学习总结-多线程多进程学习.docx
06-10
以上知识点涵盖了多线程多进程编程的基本要素，包括进程线程的创建与管理、同步机制、进程间通信方式以及工程构建和库的使用。理解并掌握这些内容，能够帮助开发者编写高效、稳定的多线程多进程应用程序。
jc.rar_进程的管道通信
09-14
总的来说，“jc.rar_进程的管道通信”这一主题为我们提供了一个深入学习进程间通信机制的机会，通过理解并实践管道通信，我们可以更好地掌握多进程协同工作的方法，这对于编写高效、可靠的多线程和分布式系统至关...
Linux进程间通信②：有名管道FIFO
一只老风铃
10-11 335
常规的匿名管道通过pipe创建一片内存缓冲区，并对外提供两个文件描述符，用于只读或者只写操作。但其使用范围很小，只能用于父、子进程间的通信。因此Linux还提供有名管道的支持。 管道的本质是一片可以读写的缓冲区域，Linux将其描述为文件（UNIX思想：一切IO皆是文件） 对于有名管道，其主要特点是： 存在于文件系统中，包含文件名，管道文件被组织成树状结构 两个进程之间无需有联系，可以通过管道进行通信 对有名管道的操作和文件操作类似，支持读，写 【有名管道的创建】 mkfifo(const.
进程间通信——FIFO（多个客户进程，一个服务进程）
weixin_30463341的博客
11-02 283
FIFO简介 FIFO就是Unix的一种复合POSIX标准的进程间通信机制。他又称为命名管道，跟管道的不同点是，每个FIFO都有一个路径名与之关联。 FIFO虽然有路径名，但是他这中文件是在内核态（管道也是在内核态），跟文件系统没有关系。 单个服务器进程，多个客户端进程与服务器进通信。客户端进程想服务器进程发送请求（客户端进程通过write写FIFO），服务端处理（通过read读客户进程的请...
linux 练习七 线程键用有名管道FIFO通信
hexiechina2010的专栏
12-07 374
题目：利用多线程与有名管道技术，实现两个进程之间发送即时消息，实现聊天功能 思路：关键在于建立两个有名管道，利用多线程技术，进程A中线程1向管道A写数据，进程B中线程2从管道A读数据，进程A线程2从管道B中读数据，进程B中线程1往管道B中写数据 //线程和FIFO练习//pthreadtest.c #include #include #include #include #inc
Linux fifo实现服务，端客户端的双向通信
0729Liang
04-10 1933
FIFO的使用简单介绍下代码的运行过程，简单说类似qq的收发消息，随时可写，随时可读，    写入EOF会终止发送方的写，接收方的读    读取EOF会终止接收方的读，接收方还可以继续写运行截图：这用到了pipe创建子进程，    服务端子进程用于读，有可读消息便显示，父进程用于发送，有输入消息便发送    客户端子进程用于写，有输入消息便发送，父进程用于读，有可读消息便显示1.首先建立服务端se...
FIFO实现并发服务器——多进程
weixin_38044916的博客
10-27 558
/*服务器*/ #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<sys/stat.h> #include<unistd.h> #include<fcntl.h> #include<string.h> #include<errno.h> #define SERVER_FIFO "server_fifo"/*服务器管
【FPGA】UART串口通信---基于FIFO
wanerXR的博客
06-04 9800
我们在上一章完成了UART串口通信的收发模块，这一章我们将FIFO引入进来，使用FIFO进行缓存数据，来连接串口通信的收发模块同步FIFO 读和写应用同一个时钟。它的作用一般是做交互数据的一个缓冲，也就是说它的主要作用就是一个buffer1。异步FIFO 读写应用不同的时钟，它有两个主要的作用，一个是实现数据在不同时钟域进行传递，另一个作用就是实现不同数据宽度的数据接口。同步FIFO和异步FIFO略有不同，下面的参数适用于两者。，用参数FIFO_data_size表示，也就是FIFO存储的数据宽度； ，用参
命名管道实现进程的信息传递【mkfifo函数、open函数】
Jormungand_V的博客
08-13 401
文章目录代码实现mkfifo函数open函数 代码实现 #include<fcntl.h> // open() #include<sys/wait.h> // wait() #include<sys/types.h> // mkfifo() #include<sys/stat.h> // mkfifo() #include<iostream> #include<unistd.h> // fork() using namespace
C++多线程编程学习三 [FIFO队列设计]
nellson的专栏
02-06 1693
   在网络编程中，FIFO队列是经常使用到的一个数据缓冲机制，同时这也是一个生产者与消费者问题，在设计过程中要注意以下几点。队列大小设计要科学，对于服务的强度而言，有一个最优化长度，要通过测试去发掘。数据竞争保护，通过设定条件互斥量，对涉及队列的操作进行保护。事件通知策略，两个线程，一个读，一个写，每写一个数据到队列中就要进行“事件通知”，而读消息每     次读消息前都要检测事件是否处在信号通
多进程编程——管道
weixin_42736024的博客
12-03 579
进程间通讯有四种方式：信号量、管道、消息队列、共享内存   我们以前已经介绍过了信号量，今天我们着重介绍一下管道。   管道可以分为有名管道和无名管道。 有名管道    有名管道利用管道文件实现进程间通讯，管道文件仅仅是磁盘上的一个文件标识，其真实数据存储在内存上。 1.命令：mkfifo  filename 2.函数：int   mkfifo(); 对于管道文件的打开操作，必须是有...
Linux进程间通信：管道与命名管道详解
在Linux系统中，有多种方式实现进程间的通信，包括信号、信号量、命名信号量、管道、命名管道（FIFO）、共享内存以及套接字等。 1. **信号（Signal）**： - 信号是一种异步通信机制，可以由操作系统发送给进程，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值