有名管道实现通信

持续更新中～

已于 2024-08-06 08:48:36 修改

阅读量176

点赞数 2

文章标签： linux 运维服务器

于 2024-08-05 22:33:40 首次发布

本文链接：https://blog.csdn.net/2301_76740986/article/details/140937913

版权

1>使用有名管道实现，一个进程用于给另一个进程发消息，另一个进程收到消息后，展示到终端上，并且将消息保存到文件上

mkfifo.c

     1	#include<myhead.h>
     2	int main(int argc, const char *argv[])
     3	{
     4		//创建一个有名管道文件
     5		if(mkfifo("./linux",0664)==-1)
     6		{
     7			perror("mkfifo error");
     8			return -1;
     9		}
    10		getchar();
    11		system("rm linux");
    12		return 0;
    13	}

process1.c

     1	#include<myhead.h>
     2	int main(int argc, const char *argv[])
     3	{
     4		//以读的形式打开文件
     5		int rfd=open("./linux",O_RDONLY);
     6		if(rfd==-1)
     7		{
     8			perror("open error");
     9			return -1;
    10		}
    11		printf("管道文件读端打开\n");
    12	
    13		//以写打开文件,保存传入的信息
    14		int fd=open("./lx.txt",O_WRONLY|O_CREAT|O_TRUNC,0664);
    15		if(fd==-1)
    16		{
    17			perror("open error");
    18			return -1;
    19		}
    20	
    21		//定义接受容器
    22		char rbuf[128]="";
    23		while(1)
    24		{
    25			bzero(rbuf,sizeof(rbuf));
    26			//读取数据
    27			read(rfd,rbuf,sizeof(rbuf));
    28			if(strcmp(rbuf,"quit")==0)
    29			{
    30				break;
    31			}
    32	
    33			//在终端输出收到的消息
    34			printf("收到消息为:%s\n",rbuf);
    35	
    36			//将收到的消息写入到文件中
    37			write(fd,rbuf,sizeof(rbuf));
    38	
    39			char a='\n';
    40			write(fd,&a,1);
    41	
    42		}
    43	
    44		//关闭文件描述符号
    45		close(rfd);
    46		close(fd);
    47		return 0;
    48	}

process2.c

     1	#include<myhead.h>
     2	int main(int argc, const char *argv[])
     3	{
     4		//以写的形式打开文件
     5		int wfd=open("./linux",O_WRONLY);
     6		if(wfd==-1)
     7		{
     8			perror("open error");
     9			return -1;
    10	
    11		}
    12		printf("管道文件已经打开\n");
    13	
    14		//发送数据
    15		char wbuf[128]="";
    16		while(1)
    17		{
    18			printf("请输入>>>");
    19			fgets(wbuf,sizeof(wbuf),stdin);
    20			wbuf[strlen(wbuf)-1]=0;
    21	
    22	
    23			//将数据发送到管道中
    24			write(wfd,wbuf,strlen(wbuf));
    25	
    26			//判读数据
    27			if(strcmp(wbuf,"quit")==0)
    28			{
    29				break;
    30			}
    31		}
    32		//关闭文件描述符
    33		close(wfd);
    34		return 0;
    35	}

2>使用有名管道实现两个进程间相互通信

process_one.c

     1	#include<myhead.h>
     2	int main(int argc, const char *argv[])
     3	{
     4		//定义变量存储进程的pid号
     5		pid_t pid = -1;
     6	
     7		//创建一个子进程
     8		pid=fork();
     9	
    10		//对pid进行判断
    11		if(pid<0)
    12		{
    13			perror("fork error");
    14			return -1;
    15		}
    16		else if(pid==0)        //子进程
    17		{
    18			
    19	
    20				//以读的形式打开管道文件2
    21				int rfd=open("./linux2",O_RDONLY);
    22				if(rfd==-1)
    23				{
    24					perror("open error");
    25					return -1;
    26				}
    27				printf("管道文件2读端已经打开\n");
    28	
    29				//搬运工
    30				char rbuf[128]="";
    31				while(1)
    32				{
    33					//清空容器
    34					bzero(rbuf,sizeof(rbuf));
    35	
    36					//读取数据
    37					read(rfd,rbuf,sizeof(rbuf));
    38					if(strcmp(rbuf,"quit")==0)
    39					{
    40						break;	
    41					}
    42					printf("进程A收到的消息:%s\n",rbuf);
    43				}
    44	
    45	
    46			close(rfd);
    47			exit(EXIT_SUCCESS);
    48	
    49		}
    50	
    51		//以写的形式打开管道文件1
    52		int wfd = open("./linux1",O_WRONLY);
    53		if(wfd==-1)
    54		{
    55			perror("open error");
    56			return -1;
    57		}
    58	
    59		printf("管道文件1写端已经打开\n");
    60	
    61		//搬运工
    62		char wbuf[128]="";
    63		while(1)
    64		{
    65			printf("进程A发送的消息:");
    66			fgets(wbuf,sizeof(wbuf),stdin);
    67			wbuf[strlen(wbuf)-1]=0;
    68	
    69			//将数据发送到管道中
    70			write(wfd,wbuf,strlen(wbuf));
    71	
    72			//退出判断
    73			if(strcmp(wbuf,"quit")==0)
    74			{
    75				break;
    76			}
    77		}
    78		//关闭文件描述符  
    79		close(wfd);
    80	
    81	
    82		return 0;
    83	}
    84

process_two.c

    1	#include<myhead.h>
     2	int main(int argc, const char *argv[])
     3	{
     4		//定义变量存储进程的pid号
     5		pid_t pid = -1;
     6	
     7		//创建一个子进程
     8		pid=fork();
     9	
    10		//对pid进行判断
    11		if(pid<0)
    12		{
    13			perror("fork error");
    14			return -1;
    15		}
    16		else if(pid==0)   //子进程
    17		{
    18			
    19			
    20				//以写的形式打开管道文件2
    21				int wfd = open("./linux2",O_WRONLY);
    22				if(wfd==-1)
    23				{
    24					perror("open error");
    25					return -1;
    26				}
    27	
    28				printf("管道文件2写端已经打开\n");
    29	
    30				//搬运工
    31				char wbuf[128]="";
    32				while(1)
    33				{
    34					printf("进程B发送的消息:");
    35					fgets(wbuf,sizeof(wbuf),stdin);
    36					wbuf[strlen(wbuf)-1]=0;
    37	
    38					//将数据发送到管道中
    39					write(wfd,wbuf,strlen(wbuf));
    40	
    41					//退出判断
    42					if(strcmp(wbuf,"quit")==0)
    43					{
    44						break;
    45					}
    46				}
    47				//关闭文件描述符  
    48				close(wfd);
    49				exit(EXIT_SUCCESS);
    50	
    51	
    52		}
    53	
    54		//以读的形式打开管道文件1
    55		int rfd=open("./linux1",O_RDONLY);
    56		if(rfd==-1)
    57		{
    58			perror("open error");
    59			return -1;
    60		}
    61		printf("管道文件1读端已经打开\n");
    62	
    63		//搬运工
    64		char rbuf[128]="";
    65		while(1)
    66		{
    67			//清空容器
    68			bzero(rbuf,sizeof(rbuf));
    69	
    70			//读取数据
    71			read(rfd,rbuf,sizeof(rbuf));
    72			if(strcmp(rbuf,"quit")==0)
    73			{
    74				break;	
    75			}
    76			printf("进程B收到的消息:%s\n",rbuf);
    77		}
    78	
    79	
    80		//关闭文件描述符
    81		close(rfd);
    82	
    83	
    84		return 0;
    85	}
    86

需要创建管道两个管道

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //创建有名管道文件
    if(mkfifo("./linux1", 0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }

    getchar();
    system("rm linux1");

    return 0;
}