linux进程间通讯-有名管道

最新推荐文章于 2022-06-16 10:50:50 发布
最新推荐文章于 2022-06-16 10:50:50 发布
阅读量405 收藏
点赞数
分类专栏： linux系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44681745/article/details/116106045
版权

文章目录

阻塞和非阻塞概念

如果是阻塞，管道中没有数据，read会一直等待，直到有数据才会继续运行，否则一 直等待。
如果是非阻塞，read函数运行时，会先看一下管道中是否有数据，如果有数据，则正常运行读取数据，如果管道中没有数据，则read函数会立即返回，继续下面的代码运行。

通过fcntl函数设置文件的阻塞特性

功能函数
设置为阻塞：fcntl(fd, F_SETFL, 0);
设置为非阻塞：fcntl(fd, F_SETFL, O_NONBLOCK);
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
	int fd_pipe[2];
	char buf[] = "hello world";
	pid_t pid;
	if (pipe(fd_pipe) < 0)
	{
		perror("fail to pipe");
		exit(1);
	}
	pid = fork();
	if (pid < 0)
	{
		perror("fail to fork");
		exit(0);
	}
	if (pid == 0)
	{
		while(1)
		{
			sleep(5);
			write(fd_pipe[1], buf, strlen(buf));
		}
	}
	else
	{
		//将fd_pipe[0]设置为阻塞
	    //fcntl(fd_pipe[0], F_SETFL, 0);
		//将fd_pipe[0]设置为非阻塞
		fcntl(fd_pipe[0], F_SETFL, O_NONBLOCK);
		while(1)
		{
			memset(buf, 0, sizeof(buf));
			read(fd_pipe[0], buf, sizeof(buf));
			printf("buf=[%s]\n", buf);
			sleep(1);
		}
	}
	return 0;
}

在这里插入图片描述

文件描述符概述

文件描述符是非负整数，是文件的标识。 用户使用文件描述符（file descriptor）来访问文件。
利用open打开一个文件时，内核会返回一个文件描述符。 每个进程都有一张文件描述符的表，进程刚被创建时，标准输入、标准输出、标准错误输出设备文件被打开，对应的文件描述符0、1、2 记录在表中。
在进程中打开其他文件时，系统会返回文件描述符表中最小可用的文件描述符，并将此文件 描述符记录在表中。
注意： Linux中一个进程最多只能打开NR_OPEN_DEFAULT （即1024）个文件，故当文件不再使用时应及时调用close函数关闭文件。
例子

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    //在进程中打开其他文件时，
    //系统会返回文件描述符表中最小可用的文件描述符，
    //并将此文件描述符记录在进程的文件描述符表中。
    close(0);
    int fd1, fd2, fd3;
    fd1 = open("file.txt", O_RDONLY | O_CREAT, 0664);
    fd2 = open("file.txt", O_RDONLY | O_CREAT, 0664);
    fd3 = open("file.txt", O_RDONLY | O_CREAT, 0664);
    printf("fd1 = %d\n", fd1);
    printf("fd2 = %d\n", fd2);
    printf("fd3 = %d\n", fd3);
        return 0;
}

在这里插入图片描述

文件描述符的复制

dup函数
在这里插入图片描述

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main(void)
{
    //通过dup函数复制一个文件描述符
    int fd;
    //dup执行后给返回值文件描述符分配的值是文件描述符表中最小可用的文件描述符
    fd = dup(1);
    printf("fd = %d\n", fd);
    //由于通过dup函数将1这个文件描述符复制了一份为fd，所以fd现在就相当于1，所以写数据就是想终端写入数据
    write(fd, "nihao beijing\n", strlen("nihao beijing\n"));
    return 0;
}

在这里插入图片描述
实现输出重定向的功能

如果需要实现输出重定向的功能 
首先像printf函数是操作文件描述符1所对应的文件，默认是操作终端，只要能够把1对应标识的文件改变，
就可以实现输出重定向。所以实现创建好文件对应的文件描述符之后，将1文件描述符关闭，接着通过dup 
函数复制的新的文件描述符就是1，这样printf函数对1操作，就写到了文件中。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
	//如果需要实现输出重定向的功能
	//首先像printf函数是操作文件描述符1所对应的文件，
	//默认是操作终端，只要能够把1对应标识的文件改变，就可以实现输出重定向
	//所以实现创建好文件对应的文件描述符之后，将1文件描述符关闭，接着通过dup
	//函数复制的新的文件描述符就是1，这样printf函数对1操作，就写到了文件中
	int fd_file;
	fd_file = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0664);
	if(fd_file == -1)
	{
		perror("fail to open");
		exit(1);
	}
	close(1);
	int fd = dup(fd_file);
	printf("hello world\n");
	printf("fd = %d\n", fd);
	return 0;
}

在这里插入图片描述
实现输出重定向后，还想标准输出

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
	int fd1;
	int fd2;
	fd2 = dup(1);
	printf("new:fd2 = %d\n",fd2);
	fd1 = open("test.txt", O_RDWR | O_CREAT, 0664);
	close(1);
	int fd3 = dup(fd1);
	printf("hello world\n");
	printf("fd = %d\n", fd3);
	close(1);
	int fd4 = dup(fd2);
	printf("nihao beijing\n");
	printf("fd = %d\n", fd4);
	return 0;
}

在这里插入图片描述

有名管道

命名管道(FIFO)和管道(pipe)基本相同，但也有一些显著的不同， 其特点是:
1、半双工，数据在同一时刻只能在一个方向上流动。
2、写入FIFO中的数据遵循先入先出的规则。
3、FIFO所传送的数据是无格式的，这要求FIFO的读出方与写入方必须事先约定好数据的格 式，如多少字节算一个消息等。
4、FIFO在文件系统中作为一个特殊的文件而存在并且在文件系统中可见，所以有名管道可 以实现不相关进程间通信，但FIFO中的内容却存放在内存中。
5、管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。
6、从FIFO读数据是一次性操作，数据一旦被读，它就从FIFO中被抛弃，释放空间以便写更 多的数据。
7、当使用FIFO的进程退出后，FIFO文件将继续保存在文件系统中以便以后使用。
8、FIFO有名字，不相关的进程可以通过打开命名管道进行通信。

有名管道的创建

在这里插入图片描述

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
//有名管道创建
int main()
{
    if((mkfifo("./file",0600)==-1)&&errno!=EEXIST)
    {
        printf("mkfifo failued\n");
        perror("why");
    }else if(errno==EEXIST)
        {
            printf("file exist\n");
        }
    else{
        printf("suscceess\n");
    }
    return 0;
}

在这里插入图片描述

有名管道的基本读写操作

由于有名管道在本地创建了一个管道文件，所以系统调用的IO函数基本都可以对有名管道进行操作， 但是不能使用lseek修改管道文件的偏移量。
注意：有名管道创建的本地的文件只是起到标识作用，真正有名管道实现进程间通信还是在内核空间开辟内存，所以本地产生的文件只是一个标识，没有其他作用，对本地管道文件的 操作实质就是对内核空间的操作。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#define FIFONAME "fifo_file"
int main(int argc, char const *argv[])
{
    //通过mkfifo函数创建有名管道
    if(mkfifo(FIFONAME, 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }
    //对有名管道进行操作
    //管道后写入的数据会保存在之前写入数据的后面，不会替换
    //如果管道中没有数据了，读操作会阻塞
    //通过open函数打开管道文件并得到文件描述符
    int fd;
    fd = open(FIFONAME, O_RDWR);
    if(fd == -1)
    {
        perror("fail to open");
        exit(1);
    }
    //通过write函数向管道中写入数据
    if(write(fd, "hello world", strlen("hello world")) == -1)
    {
        perror("fail to write");
        exit(1);
    }
    write(fd, "nihao beijing", strlen("nihao beijing"));
    //通过read函数读取管道中的数据
    char buf[32] = "";
    if(read(fd, buf, sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("buf = [%s]\n", buf);
    if(read(fd, buf, sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("buf = [%s]\n", buf);
    //使用close函数关闭文件描述符
    close(fd);
    return 0;
}

在这里插入图片描述

有名管道实现进程间通信

由于有名管道在本地创建了一个管道文件，所以不相关的进程间也可以实现通信。
send

#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>
int main(int argc, char const *argv[])
{
    //如果没有创建有名管道，则创建有名管道
    //为了实现两个进程都可以收发数据，所以需要创建两个有名管道
    if(mkfifo("myfifo1", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }
    if(mkfifo("myfifo2", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }
    //打开两个有名管道并得到文件描述符
    int fd_w, fd_r;
    if((fd_w = open("myfifo1", O_WRONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }
    if((fd_r = open("myfifo2", O_RDONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }
    char buf[128] = "";
    ssize_t bytes;
    while(1)
    {
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf) - 1] = '\0';
        //send进程负责将数据写入myfifo1，接着从myfifo2中读取数据
        if((bytes = write(fd_w, buf, sizeof(buf))) == -1)
        {
            perror("fail to write");
            exit(1);
        }
        if((bytes = read(fd_r, buf, sizeof(buf))) == -1)
        {
            perror("fail to read");
            exit(1);
        }
        printf("from recv: %s\n", buf);
    }
    return 0;
}

** recv**

#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>
int main(int argc, char const *argv[])
{
    //如果没有创建有名管道，则创建有名管道 
    //为了实现两个进程都可以收发数据，所以需要创建两个有名管道
    if(mkfifo("myfifo1", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }
    if(mkfifo("myfifo2", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }
    //打开两个有名管道并得到文件描述符
    int fd_w, fd_r;
    if((fd_r = open("myfifo1", O_RDONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }
    if((fd_w = open("myfifo2", O_WRONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }
    char buf[128] = "";
    ssize_t bytes;
    while(1)
    {
        if((bytes = read(fd_r, buf, sizeof(buf))) == -1)
        {
            perror("fail to read");
            exit(1);
        }
        printf("from send: %s\n", buf);
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf) - 1] = '\0';
        write(fd_w, buf, sizeof(buf));
    }
    return 0;
}

在这里插入图片描述

有名管道的读写规律（阻塞）

读写端都存在，只读不写
如果原本管道中有数据，则正常读取。
如果管道中没有数据，则read函数会阻塞等待。
读写端都存在，只写不读
当有名管道的缓冲区写满后，write函数会发生阻塞。
默认有名管道的缓冲区为64K字节。
在一个进程中，只有读端，没有写端
在一个进程中，只有读端，没有写端。
会在open函数的位置阻塞。
在一个进程中，只有写端，没有读端
在一个进程中，只有写端，没有读端。
会在open函数的位置阻塞。
一个进程只读，一个进程只写
只要保证有名管道的读写端都存在，不管是几个进程，都不会再open这阻塞了。
如果一个进程只读，一个进程只写，都运行后，如果关闭写端，读端read会返回0。
如果一个进程只读，一个进程只写，都运行后，如果关闭读端，写端会立即产生 SIGPIPE信号，默认的处理方式是退出进程。

兔子警官QAQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux环境进程间通信-管道及有名管道.docx
09-26
Linux环境进程间通信-管道及有名管道.docx
linux输出管道到2,linux 输入输出重定向以及管道
weixin_34663036的博客
05-14 124
输入/输出重定向，管道1、标准输入：/dev/stdin(键盘)， 描述符号是02、标准输出：/dev/stdout(屏幕)， 描述符号是13、错误输出：/dev/stderr(错误消息输出到屏幕上)，描述符号是2COMMAND_OUTPUT > OUTPUT_FILENAME#重定向stdout到一个文件#如果没有这个文件就创建...
linux有名管道 同步,Linux有名管道的 阻塞VS非阻塞 读写
weixin_39604685的博客
05-13 214
WPF整理-处理没有注意到的异常在.NET中,我们使用try-catch-finally来处理异常.但,当一个Exception抛出,抛出Exception的代码又没有被try包围时,程序就崩溃了. 这些异常往往是你没有注意到的.在 ...Mysql InnoDB行锁实现方式Mysql InnoDB行锁实现方式 InnoDB行锁是通过给索引上的索引项加锁来实现的,这一点MySQL与Oracle不同...
Linux系统编程之进程间通讯的主要方式
^_^
02-04 304
《Linux管道使用》 POSIX(Portable Operating System Interface)：表示可移植操作系统接口。 Linux进程间通讯的主要方式有： 无名管道（pipe） 有名管道（FIFO） 信号（signal） 消息队列 共享内存 信号量 套接字（socket） 【管道】
有名管道open阻塞问题
ljq550000的专栏
07-12 1140
又名管道open也会阻塞 请小心
linux 无名管道阻塞,进程之间通信之有名管道、无名管道（pipe），笔记
weixin_42528296的博客
05-14 189
进程之间的通信作用1、数据传输 :一个进程需要将他的数据传到其他进程2、资源共享3、进程通知事件4、进程控制 :有些进程完全控制另一个进程的执行，如调试状态啊我们需要完全控制他的每一步操作；通信发展历史Linux进程间的通信IPC由以下几个部分发展而来：1、UNIX进程之间的通信2、基于system v进程间的通信3、POSIX进程之间的通信(portable operating system...
Linux通过匿名管道进行进程间通信
09-15
主要介绍了Linux通过匿名管道进行进程间通信，介绍了什么是管道，popen函数，pipe调用等相关内容，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
linux环境进程间通信之有名管道-fisher0821-ChinaUnix博客1
08-03
1.有名管道的创建 2.有名管道的打开规则： 3.有名管道读写规则：
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
Linux进程间通讯
02-02
IPC基本概念，无名管道(pipe)概念与编程，有名管道(fifo)概念与编程，信号概念与编程，定时器
linux 命名管道
spygg的专栏
08-03 670
#include #include #include #include #include #include #include /* *     As for the fifo we can creat it use both *     mkfifo(const char *pathname,mode_t mode); *   and  *   mknod(); to rea
关于有名管道( fifo)open时阻塞的问题
zg915355901的博客
12-04 3701
问题： 有名管道，mkfifo了两个文件，然后文件io-open打开的时候，阻塞在open里面了，找了好久，没找到，无解网上搜索。 分析： 一般情况下（没有指定O_NONBLOCK）,只读open要阻塞到某个其他进程为写而打开这个FIFO为止。类似的，只写open要阻塞到某个其他进程为读而打开它为止。 如果指定了O_NONBLOCK，则只读open立即返回，但是如果没有进程为读...
Linux：匿名管道的阻塞属性
qq_45481606的博客
08-03 1001
管道阻塞特性（10个）： 1. 管道是半双工通信，数据流只能从写端流向读端 ps aux | grep mypipe ps aux命令通过写端往管道中写，grep通过读端进行读，数据流向是从写端到读端 从PCB角度去理解管道： 当前进程调用pipe函数，进程里有一个task_struct结构体； task_struct结构体中有一个struct files_struct* files的指针； 该指针指向对应的结构体struct files_struct； 在这个结构体中有一个fd_array的数组； 数
（转）关于有名管道open时阻塞的问题
kuimzzs的博客
02-18 871
遇到一个问题，刚好这位博主有总结，转一下 原文：https://blog.csdn.net/men_wen/article/details/59158365  关于有名管道open时阻塞的问题 1. 发现错误 在学习Unix网络编程卷二的有名管道FIFO时，无意间犯下一个错误，故写此总结。  在写FIFO的服务器和客户端之间通信的代码时，服务器端主函数创建两个有名管道，然后分被以读写打开两个...
c语言系统编程七：Linux进程间通信之有名管道
qq_33808440的博客
06-16 517
有名管道 需要的头文件和函数原型 参数 返回值 四 有名管道案例 六 命名管道实例-单机qq聊天 实现单机QQ聊天。提示：父进程创建子进程，实现多任务。父进程负责发消息（向FIFO里写数据），子进程负责接收信息（从FIFO里读数据）。打开命名管道用阻塞方式打开。...
Linux有名管道（FIFO）的阻塞和非阻塞读写
热门推荐
u014285517的专栏
01-09 2万+
有名管道的读写有阻塞和非阻塞两种，可以在open()时指定，下面我们对各种情况进行一些讨论。 //写进程#include #include #include #include #include #include #define FIFO_NAME "/tmp/myfifo" main() { int fd; char w_buf[50]; int w_num;
进程间通信--------有名管道如何产生阻塞
沉西乐恩的博客
06-10 2150
使用有名管道时，我们经常想要的是这样：在有名管道中没有数据时A进程挂起，当B进程往有名管道里写数据时激活A进程。于是就得考虑有名管道是如何使进程挂起，我们又当如何设置。     首先，在创建管道成功后，我们可以使用open()、read()和write()这些函数来操作有名管道。与普通文件的开发设置一样，对于为读而打开的管道可在open()中设置O_RDONLY，对于为写而打开的管道可在open
linux进程通信中有名管道的特点,linux进程通信之(四):有名管道的读与写
weixin_31232695的博客
04-29 363
前面我们说了无名管道,下面我们来说说有名管道,请看下面一段代码:fifo_write.c:#include#include#include#include#include#include#include#define FIFO "/tmp/myfifo"void main(int argc,char **argv)//参数为即将写入的字节数{int fd;char w_buf[100];int n...
linux 有名管道
最新发布
11-10
有名管道是一种特殊的文件类型，它提供了进程间通信的一种方式。在Linux中，有名管道也被称为FIFO（First In First Out）。下面是有关有名管道的一些介绍和使用方法： 1. 有名管道是一种特殊的文件类型，它可以在不相关的进程之间传递数据。 2. 有名管道可以通过mkfifo命令创建，也可以在程序中使用mkfifo()函数创建。 3. 有名管道的读写方式类似于普通文件的读写方式，可以使用open()、read()、write()等函数进行操作。 4. 有名管道的读写特性：当管道中有数据时，read()函数返回实际读到的字节数；当管道中没有数据时，read()函数会阻塞等待；当管道写端被全部关闭时，read()函数返回0，相当于读到文件末尾。 5. 当管道读端全部关闭时，进程异常终止，收到信号SIGPIPE；当管道读端没有被全部关闭时，如果管道已经满了，write()函数会阻塞等待；如果管道没有满，write()函数将数据写入，并返回实际写入的字节数。 下面是一个简单的使用有名管道完成聊天功能的例子： ```bash # 创建有名管道 mkfifo chat_pipe # 进程1写入数据到管道 echo "Hello, this is process 1." > chat_pipe # 进程2从管道中读取数据 cat chat_pipe ``` 以上命令中，进程1向管道中写入了一条消息，进程2从管道中读取了这条消息并输出。这样就完成了一个简单的聊天功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值