【0805作业】Linux中 AB终端通过两根有名管道进行通信聊天（半双工）（全双工）

已于 2023-08-07 22:52:13 修改
阅读量573 收藏 2
点赞数
分类专栏： IO进程线程 # 网络编程作业 # IPC 文章标签： linux c# c语言
于 2023-08-05 18:48:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smallxu_/article/details/132122993
版权
本文介绍了如何使用C++在两个终端通过mkfifo创建的管道实现AB进程间的全双工通信，包含发送和接收消息流程及退出条件。
摘要由CSDN通过智能技术生成

作业一：打开两个终端，要求实现AB进程对话【两根管道】

打开两个终端，要求实现AB进程对话

  1. A进程先发送一句话给B进程，B进程接收后打印
  2. B进程再回复一句话给A进程，A进程接收后打印
  3. 重复1.2步骤，当收到quit后，要结束AB进程
  • 提示：两根管道

A终端代码

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

/***************************A终端***************************/

int main(int argc, const char *argv[])
{
	//创建管道1    A终端写入--->管道1--->B终端读取
	if(mkfifo("./fifo",0664) < 0)
	{
		if(errno != 17)//如果错误是已有管道，则跳过，可正常运行
		{
			perror("mkfifo");
			return -1;
		}
	}
	printf("mkfifo pipe1 success __%d__\n",__LINE__);

	//创建管道2    B终端写入--->管道2--->A终端读取
	if(mkfifo("./myfifo",0664) < 0)
	{
		if(errno != 17)
		{
			perror("mkfifo");
			return -1;
		}
	}
	printf("mkfifo pipe2 success __%d__\n",__LINE__);

	//以写的方式打开管道1
	int fd_w=open("./fifo",O_WRONLY);
	if(fd_w < 0)
	{
		perror("open");
		return -1;
	}
	printf("open pipeA success __%d__\n",__LINE__);
	//以读的方式打开管道B
	int fd_r=open("./myfifo",O_RDONLY);
	if(fd_r < 0)
	{
		perror("open");
		return -1;
	}
	printf("open pipeB success __%d__\n",__LINE__);


	char buf[128]="";
	ssize_t res = 0;
	int c=-1;
	while(1)
	{
		//管道1操作（写入数据）
		printf("请输入要对B说的话>>> ");
		fgets(buf,sizeof(buf),stdin);    //从终端获取数据

		buf[strlen(buf)-1] = '\0';   //将\n改成\0
		if((write(fd_w,buf,sizeof(buf))) < 0)  //将字符串写进管道A  
		{
			perror("write");
			return -1;
		}
		//当管道1的读段关闭，管道1的写段尝试写入数据，则管道破裂，退出进程



		//管道2操作（读取数据）
		bzero(buf,sizeof(buf));//清空字符串
		res=read(fd_r,buf,sizeof(buf));//读取B管道中的数据
		
		c=strcmp(buf,"quit");//将读到的数据与quit比较
		if(0 == c)//如果相同，c为0，达到退出条件，可以退出循环
		{
			break;
		}
		//printf("写入数据成功 res=%ld\n",res);

		if(res < 0)//read函数执行失败，返回负数
		{
			perror("read");
			return -1;
		}   

		if(0 == res)//read执行成功，但读到了0个数据`
		{
			printf("对方进程退出\n");
			break;
		}
		//打印从管道2中读取到的数据
		printf("B:%s\n",buf);
	}
	
	//关闭管道1、管道2
	close(fd_r);
	close(fd_w);
	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>

/***************************B终端***************************/  

int main(int argc, const char *argv[])
{
	//创建管道1   A终端写入--->管道1--->B终端读取
	if(mkfifo("./fifo",0664) < 0)
	{
		if(errno != 17)
		{
			perror("mkfifo");
			return -1;
		}
	}
	printf("mkfifo pipe1 success __%d__\n",__LINE__);

	//创建管道2   B终端写入--->管道2--->A终端读取
	if(mkfifo("./myfifo",0664) < 0)
	{
		if(errno != 17)
		{
			perror("mkfifo");
			return -1;
		}
	}
	printf("mkfifo pipe2 success __%d__\n",__LINE__);
	
	//以读的方式打开管道1
	int fd_r=open("./fifo",O_RDONLY);
	if(fd_r < 0)
	{
		perror("open");
		return -1;
	}
	printf("open pipe1 success __%d__\n",__LINE__);
	//以写的方式打开管道2
	int fd_w=open("./myfifo",O_WRONLY);
	if(fd_w < 0)
	{
		perror("open");
		return -1;
	}
	printf("open pipe2 success __%d__\n",__LINE__);

	char buf[128]="";
	ssize_t res = 0;
	int c=-1;
	while(1)
	{
		//管道1操作（读取数据）
		bzero(buf,sizeof(buf));
		res=read(fd_r,buf,sizeof(buf));

		c=strcmp(buf,"quit");//判断B终端输入的是否是quit
		if(0 == c)
		{
			break;//是quit则退出进程
		}
		if(res < 0)
		{
			perror("read");
			return -1;
		}
		if(0 == res )
		{
			printf("对方进程退出\n");
			break;
		}
		printf("A:%s\n",buf);

		//管道2操作（写入数据）
		printf("请输入>>> ");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1] = '\0';
		if((write(fd_w,buf,sizeof(buf))) < 0)
		{
			perror("write");
			return -1;
		}
		//当管道2关闭，管道2的写段尝试写入数据，则管道破裂，退出进程
	}

	close(fd_r);
	close(fd_w);
	return 0;
}

A终端结果

ubuntu@ubuntu:02_fifo$ gcc 03_pipe_w.c -o w
ubuntu@ubuntu:02_fifo$ ./w
mkfifo pipe1 success __22__
mkfifo pipe2 success __33__
open pipeA success __42__
open pipeB success __50__
请输入要对B说的话>>> 你好，我是A
B:你好呀，我是B
请输入要对B说的话>>> 你吃饭了吗？
B:吃了，你呢
请输入要对B说的话>>> 不告诉你
ubuntu@ubuntu:02_fifo$

B终端结果

ubuntu@ubuntu:02_fifo$ gcc 02_pipe_r.c -o r
ubuntu@ubuntu:02_fifo$ ./r
mkfifo pipe1 success __22__
mkfifo pipe2 success __33__
open pipe1 success __42__
open pipe2 success __50__
A:你好，我是A
请输入>>> 你好呀，我是B
A:你吃饭了吗？
请输入>>> 吃了，你呢
A:不告诉你
请输入>>> quit
对方进程退出
ubuntu@ubuntu:02_fifo$

fd741777d8ed4957bfa812ba1a3af75e.png

作业二：在作业一的基础上，AB能随时发信息给对方（全双工）

此代码需要双方终端都输入quit才能结束对话

A终端代码

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

/***************************A终端***************************/

int main(int argc, const char *argv[])
{
    umask(0);
    //创建管道1(发送)    A终端写入--->管道1--->B终端读取
    if(mkfifo("./fifo",0777) < 0)
    {
        if(errno != 17)//如果错误是已有管道，则跳过，可正常运行
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo pipe1 success __%d__\n",__LINE__);

    umask(0);
    //创建管道2（接收）    B终端写入--->管道2--->A终端读取
    if(mkfifo("./myfifo",0664) < 0)
    {
        if(errno != 17)
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo pipe2 success __%d__\n",__LINE__);

    //创建子进程
    pid_t cpid=fork();

    //以写的方式打开管道1
    int fd_w=open("./fifo",O_WRONLY);
    if(fd_w < 0)
    {
        perror("open");
        return -1;
    }
    printf("open pipeA success __%d__\n",__LINE__);
    //以读的方式打开管道B
    int fd_r=open("./myfifo",O_RDONLY);
    if(fd_r < 0)
    {
        perror("open");
        return -1;
    }
    printf("open pipeB success __%d__\n",__LINE__);


    char buf[128]="";
    ssize_t res = 0;
    int c=-1;

    if(0 == cpid)//子进程发送   fifo
    {
        while(1)
        {
            //管道1操作（写入数据）
            fgets(buf,sizeof(buf),stdin);    //从终端获取数据
            buf[strlen(buf)-1] = '\0';   //将\n改成\0
            if((write(fd_w,buf,sizeof(buf))) < 0)  //将字符串写进管道A  
            {
                perror("write");                                                     
                return -1;
            }
            //当管道1的读段关闭，管道1的写段尝试写入数据，则管道破裂，退出进程
            if(strcmp(buf,"quit") == 0)//如果相同，c为0，达到退出条件，可以退出循环
            {
                break;
            }
            //printf("写入数据成功 res=%ld\n",res);
        }
        close(fd_w);
        _exit(0);
    }
    else if(cpid > 0)//父进程接收  myfifo
    {
        while(1)
        {
            //管道2操作（读取数据）
            bzero(buf,sizeof(buf));//清空字符串
            res=read(fd_r,buf,sizeof(buf));//读取B管道中的数据

            if(res < 0)//read函数执行失败，返回负数
            {
                perror("read");
                return -1;
            }
            if(0 == res)//read执行成功，但读到了0个数据`
            {
                break;
            }
            if(strcmp(buf,"quit")==0)
                break;
            //打印从管道2中读取到的数据
            printf("B:%s\n",buf);
        }
        wait(NULL);
        close(fd_r);
    }

    //关闭管道1、管道2
    close(fd_r);
    close(fd_w);
    return 0;
}

B终端代码

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

/***************************B终端***************************/

int main(int argc, const char *argv[])
{
    //创建管道1(接收)   A终端写入--->管道1--->B终端读取
    if(mkfifo("./fifo",0777) < 0)
    {
        if(errno != 17)
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo pipe1 success __%d__\n",__LINE__);

    //创建管道2（发送）   B终端写入--->管道2--->A终端读取
    if(mkfifo("./myfifo",0777) < 0)
    {
        if(errno != 17)
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo pipe2 success __%d__\n",__LINE__);

    //创建子进程
    pid_t cpid=fork();

    //以读的方式打开管道1
    int fd_r=open("./fifo",O_RDONLY);
    if(fd_r < 0)
    {
        perror("open");
        return -1;
    }
    printf("open pipe1 success __%d__\n",__LINE__);
    //以写的方式打开管道2
    int fd_w=open("./myfifo",O_WRONLY);
    if(fd_w < 0)
    {
        perror("open");
        return -1;
    }                                                                                      
    printf("open pipe2 success __%d__\n",__LINE__);

    char buf[128]="";
    ssize_t res = 0;
    //int c=-1;


    if(0 == cpid)//子进程接收  fifo
    {
        while(1)
        {
            //管道1操作（读取数据）
            bzero(buf,sizeof(buf));
            res=read(fd_r,buf,sizeof(buf));

            if(res < 0)
            {
                perror("read");
                return -1;
            }
            if(0 == res )
            {
                break;
            }
            if(strcmp(buf,"quit")==0)
                break;
            printf("A:%s\n",buf);
        }
        close(fd_r);
        _exit(0);
    }
    else if(cpid > 0)//父进程发送  myfifo
    {
        while(1)
        {
            //管道2操作（写入数据）
            fgets(buf,sizeof(buf),stdin);
            buf[strlen(buf)-1] = '\0';
            if((write(fd_w,buf,sizeof(buf))) < 0)
            {
                perror("write");
                return -1;
            }
            //当管道2关闭，管道2的写段尝试写入数据，则管道破裂，退出进程
            if(strcmp(buf,"quit") == 0)//判断B终端输入的是否是quit
            {
                break;
            }
        }
        close(fd_w);
        wait(NULL);
    }
    else
    {
        perror("fork");
        return -1;
    }

    close(fd_r);
    close(fd_w);
    return 0;
}

结果

计算机网络中的三种通信方式：单工、半双工和全双工
网络技术联盟站
05-25 1574
单工、半双工和全双工是计算机网络中常见的三种通信方式。每种方式都有其独特的优点和适用场景。单工通信简单且成本低，但仅适用于单向数据传输。半双工通信可以双向传输数据，但不能同时进行，适用于需要双向但不频繁的数据交换场景。全双工通信则提供了最高的通信效率，适用于需要高性能和同时双向传输的应用。理解这三种通信方式的特点和应用场景，对于设计和实现高效的计算机网络至关重要。
【串口通信】-01-单工、半双工、全双工详解
随意的风的专栏
07-04 1044
串口通信是一种点对点的数据传输方式，数据以串行的形式在发送端和接收端之间传输。这种通信方式广泛应用于计算机与外部设备之间的数据交换，如打印机、调制解调器等。
有名管道实现全双工
weixin_44432538的博客
10-14 920
有名管道本来是半双工，但可以实现全双工。两个.c文件实现了qq的基本通信，可以做到互相发送信息且不会乱序。
Linux-C语言-利用有名管道简单实现两个进程间的全双工通信
qq_60717264的博客
08-21 3149
Linux-C语言-利用有名管道简单实现两个进程间的全双工通信
【进程间通信】管道如何实现全双工，原理与实践
YIOUTH的博客
05-13 3740
在操作系统中，管道（Pipe）是一种重要的进程间通信机制，它可以实现进程之间的数据传输。在本文中，我们将介绍如何使用管道实现全双工通信，让两个进程能够同时进行双向数据传输。
Linux进程间通信（管道）
m0_49476241的博客
07-22 804
本篇文章将给大家讲解进程间通信中的管道使用方法和概念。本篇文章就讲解到这里，下篇文章讲解fifo有名管道。
Linux下利用有名管道来实现两个客户端和一个服务器的通信
weixin_45515749的博客
08-13 1199
Linux下利用有名管道来实现两个客户端和一个服务器的通信
0805|IO进程线程day8 IPC机制（进程间通信机制）管道+信号
Smallxu_的博客
08-07 920
IPC机制：Inter Process Communication，即进程间通信机制。进程与进程间的用户空间相互独立，内核空间共享。所以如果要实现进程间的通信，需要使用进程间通信机制。IPC对象。
linux知识点
lidadang的博客
05-30 2377
1、问用锁解决两个线程同时访问同一个全局变量问题带来的坏处？答、2、两个进程同时访问一个全局变量是不安全的？答、对。3、问应用线程时一般都要结合消息队列来使用？答、对。4、问什么是线程池？应用范围有哪些？答、线程池就是多个线程处理同一个事情。1)、需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可...
Linux 相关基础笔记
a84633632的博客
12-22 910
Linux 相关基础笔记 Linux Baisc LinuxHistoryUserful link用户管理手动创建用户修改root密码LDAPldapaddldapsearchldapdeleteldappasswdldapmodifyfindC...
电源技术中的凌特推出具可变换集成终端的半双工和全双工RS485收发器
11-27
凌特公司推出具可变换、集成终端的半双工和全双工RS485收发器LTC2859和LTC2861。 传统的RS485网络要求最终用户根据双扭线的配置和节点的布局来安装120Ω的终端电阻器。随着总线的延长，最终用户必须再次改变终端。...
软件模拟串口全双工 UART，可实现单线双向半双工通信，带按键处理
07-28
用51单片机写的一个单线半双工的模拟串口通信程序，同时支持两线全双工，目前只做了1位起始位，1、1.5、2位起始位，没做校验。上一个版本的代码已经用在产品上了，这个版本的还没怎么用过，就拿了块板子验证了一下，...
【Linux】网络编程3
m0_73839343的博客
11-12 671
该数组里列出这个进程打开的所有文件的文件描述符。数组的下标是文件描述符，是一个整数，而数组的内容是一个指针，指向内核中所有打开的文件的列表，也就是说内核可以通过文件描述符找到对应打开的文件。然后每个文件都有一个inode,Socket 文件的 inode指向了内核中的Socket 结构，在这个结构体里有两个队列，分别是发送队列和接收队列，这个两个队列里面保存的是一个个struct sk_buff，用链表的组织形式串起来。在TCP通信的过程，服务器端会产生两类不同的文件描述符，一个是监听的文件描述符；
【Linux】多线程（中）
Eristic0618的博客
11-14 1059
本篇文章围绕Linux中的多线程展开讲解，包含线程互斥的概念、互斥量mutex和相关API、互斥量原理、重入和线程安全、死锁、线程同步和条件变量等内容
操作系统实验：在linux下用c语言模拟进程调度算法程序
最新发布
m0_68165821的博客
11-15 539
进程每执行一次，进程需要的时间片数减1、该进程的优先数减3。进程执行时，每运行一个时间片，进程还需要的时间片数减1，运行进程占用处理机的时间片数加1，然后比较占用CPU的时间片数是否与该进程的轮转时间片数相等，若相等则说明已达到轮转时间，应将现运行的进程排列就绪队列的末尾，调度队列上的首进程运行，且改变它们的进程状态，直至所有进程完成各自的时间片。（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
SimpleScreenRecorder, a screen recording tool for Linux
likecayon的博客
11-11 371
【代码】SimpleScreenRecorder, a screen recording tool for Linux。
gdb编译教程（支持linux下X86和ARM架构）
weixin_43246170的博客
11-12 258
5、我们先开始x86版本，这个比较简单，不需要配置交叉编译工具（当然前提是系统装了gcc和g++的环境啊）。将gdb文件拷贝到对应平台下，即可使用。（或者使用gdbserver远程调试）以上这些配置都是要跟在./configure后面的。3、解压，然后进入到目录下，打开当前目录的命令行窗口。2、下载完后拷贝到linux的x86系统。先清理下编译x86残留下的临时文件。6、限制我们来编译ARM版本。4、创建一个生成目录。我下载的8.2版本。
linux逻辑卷练习
feng68_的博客
11-15 243
从新硬盘制作三个分区每个分区都 3GB大小， 将三个分区只作为物理卷，通过这三个物理卷创建卷组 通过卷组生成一个逻辑卷，大小为7G，再将逻辑卷调整到10G。物理卷（physical volume）：简称PV。逻辑卷（logical volume）：简称LV。卷组（Volume Group）：简称VG。
初识Linux · 信号保存
更新各种计算机技能~
11-15 812
前文我们已经介绍了信号产生，在时间的学习线上，信号的学习分为预备知识，信号产生，信号保存，信号处理，本文我们学习信号保存，在前言部分，我们介绍几个信号保存中的概念。信号递达：实际执行信号的处理动作。信号未决：信号从产生到递达之间的状态。对于信号产生之后，在递达的这个过程，成为未决，就像老师给你布置了作业，你接受到了做作业的这个信号，但是因为贪玩，不想做，这个状态，就是未决。
Java中的单工、半双工与全双工通信模式
在Java中，实现全双工通信同样可以利用`Socket`编程，通过服务器与客户端的配合，实现两端的双向通信。 Java的网络编程中，无论是单工、半双工还是全双工通信，都可通过Java的`***`包中的类和接口来实现。例如，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值