二.有命管道(FIFO)

2023-12-30 05:13:06

目录

1.1 有名管道概述

1.1.1有名管道特点

1.2 有名管道的创建?

1.3 有名管道的基本读写操作

1.4有名管道实现进程间通信

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

1.5.1 读写端都存在，只读不写

1.5.2 读写端都存在

，只写不读

1.5.3 在一个进程中，只有读端，没有写端

1.5.4 在一个进程中，只有写端，没有读端

1.1 有名管道概述

? ?有名管道（Named Pipe）是一种在文件系统中存在的特殊文件，它允许不相关的进程之间进行通信。与无名管道不同，有名管道通过一个路径名在文件系统中存在，并且可以由多个进程同时访问。

1.1.1有名管道特点

有名管道概述 命名管道(FIFO)和管道(pipe)基本相同，但也有一些显著的不同， 其特点是:

1、半双工，数据在同一时刻只能在一个方向上流动。

2、写入FIFO中的数据遵循先入先出的规则。

3、FIFO所传送的数据是无格式的，这要求FIFO的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息等。

4、FIFO在文件系统中作为一个特殊的文件而存在并且在文件系统中可见，所以有名管道可以实现不相关进程间通信，但FIFO中的内容却存放在内存中。

5、管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。

6、从FIFO读数据是一次性操作，数据一旦被读，它就从FIFO中被抛弃，释放空间以便写更 多的数据。

7、当使用FIFO的进程退出后，FIFO文件将继续保存在文件系统中以便以后使用。

8、FIFO有名字，不相关的进程可以通过打开命名管道进行通信。

1.2 有名管道的创建?

查看系统man手册查看无名管道原型:

man 3 mkfifo

方法1：用过shell命令mkfifo创建有名管道 :mkfifo[空格]文件名。

1 方法2：使用函数mkfifo 2

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

功能：创建一个有名管道，产生一个本地文件系统可见的文件pathname。

参数： pathname：有名管道创建后生成的文件，可以带路径。

?mode：管道文件的权限，一般通过八进制数设置即可，例如0664。

返回值：成功：0 ?失败：‐1

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

int main(int argc, char const *argv[])
{
    //通过mkfifo函数创建有名管道
    if(mkfifo("fifo_file", 0664) == -1)
    {
        //printf("errno = %d\n", errno);
        //如果管道文件已经存在，不需要报错退出，直接使用即可，所以需要在错误输出之前把
        //因为文件存在的错误排除
        if(errno != EEXIST)//EEXIST文件已存在错误(17)。
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }

    return 0;
}

1.3 有名管道的基本读写操作

? ? ? 由于有名管道在本地创建了一个管道文件，所以系统调用的IO函数基本都可以对有名管道 进行操作， 但是不能使用lseek修改管道文件的偏移量。

? ? ? ?注意：有名管道创建的本地的文件只是起到标识作用，真正有名管道实现进程间通信还是在 内核空间开辟内存，所以本地产生的文件只是一个标识，没有其他作用，对本地管道文件的 操作实质就是对内核空间的操作。

? ? ? ? 操作 FIFO 文件时的特点 系统调用的 I/O 函数都可以作用于 FIFO，如 open、close、read、write 等。 打开 FIFO 时，非阻塞标志(O_NONBLOCK)产生下列影响:

特点一： 不指定 O_NONBLOCK(即 open 没有位或 O_NONBLOCK)

1、open 以只读方式打开 FIFO 时，要阻塞到某个进程为写而打开此 FIFO

2、open 以只写方式打开 FIFO 时，要阻塞到某个进程为读而打开此 FIFO。

#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;
}

1.4有名管道实现进程间通信

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

为了实现两个进程都可以收发数据，所以需要创建两个有名管道!

send.c

#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.c

#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;
}

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

1.5.1 读写端都存在，只读不写

read.c

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

int main(int argc, char const *argv[])
{
    if(mkfifo("myfifo", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }

    //读写端都存在，只读不写
    //如果原本管道中有数据，则正常读取
    //如果管道中没有数据，则read函数会阻塞等待
    
    int fd;
    if((fd = open("myfifo", O_RDWR)) == -1)
    {
        perror("fail to open");
        exit(1);
    }

    write(fd, "hello world", 11);

    char buf[128] = "";
    read(fd, buf, sizeof(buf));
    printf("buf = %s\n", buf);

    read(fd, buf, sizeof(buf));
    printf("buf = %s\n", buf);

    return 0;
}

1.5.2 读写端都存在

，只写不读

write.c

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

int main(int argc, char const *argv[])
{
    if(mkfifo("myfifo", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }

    //读写端都存在，只写不读
    //当有名管道的缓冲区写满后，write函数会发生阻塞
    //默认有名管道的缓冲区为64K字节

    int fd;
    if((fd = open("myfifo", O_RDWR)) == -1)
    {
        perror("fail to open");
        exit(1);
    }

    int num = 0;
    while(1)
    {
        write(fd, "", 1024);
        num++;
        printf("num = %d\n", num);
    }

    return 0;
}

1.5.3 在一个进程中，只有读端，没有写端

onlyRead.c

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

int main(int argc, char const *argv[])
{
    if(mkfifo("myfifo", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }

    //在一个进程中，只有读端，没有写端
    //会在open函数的位置阻塞

    printf("***********************\n");

    int fd;
    if((fd = open("myfifo", O_RDONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }

    printf("------------------------\n");

    char buf[128] = "";
    ssize_t bytes;
    while(1)
    {
        if((bytes = read(fd, buf, sizeof(buf))) == -1)
        {
            perror("fail to read");
            exit(1);
        }

        printf("bytes = %ld\n", bytes);
        printf("buf = %s\n", buf);
    }

    return 0;
}

1.5.4 在一个进程中，只有写端，没有读端

onlyWrite.c

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

int main(int argc, char const *argv[])
{
    if(mkfifo("myfifo", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }

    //在一个进程中，只有写端，没有读端
    //会在open函数的位置阻塞

    printf("*****************************\n");

    int fd;
    if((fd = open("myfifo", O_WRONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }

    printf("-----------------------------\n");

    while(1)
    {
        write(fd, "hello world", 11);
        printf("666\n");

        sleep(1);
    }

    return 0;
}

1.5.5 一个进程只读，一个进程只写

将上面onlyRead.c和onlyWrite.c两个代码一起运行，保证有名管道读写端都存在

规律：

只要保证有名管道的读写端都存在，不管是几个进程，都不会再open这阻塞了。

如果一个进程只读，一个进程只写，都运行后，如果关闭写端，读端read会返回0。

如果一个进程只读，一个进程只写，都运行后，如果关闭读端，写端会立即产生 SIGPIPE信号，默认的处理方式是退出进程。

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

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

int main(int argc, char *argv[])
{
	int fd;

	if(mkfifo("myfifo", 0664) == -1)
    {
        if(errno != EEXIST)
        {
            perror("fail to mkfifo");
            exit(1);
        }
    }
#if 0
	//如果open标志位设置为非阻塞，并且以只读的方式打开管道文件
	//open函数和read函数都不会阻塞
    fd = open("myfifo", O_RDONLY | O_NONBLOCK);
	if(fd < 0)
	{
		perror("open fifo");
		exit(1);
	}

	while(1)
	{
		char recv[100];
		
		bzero(recv, sizeof(recv));
		read(fd, recv, sizeof(recv));
		printf("read from my_fifo buf=[%s]\n",recv);
		sleep(1);
	}
#endif

#if 1
	//如果open标志位设置为非阻塞，并且以只写的方式打开管道文件
	//open函数会直接报错
	//如果open设置为可读可写，那么跟阻塞是一样的效果
    char send[100] = "Hello I love you";
	
	fd = open("myfifo", O_WRONLY | O_NONBLOCK);
	//fd = open("myfifo", O_RDWR | O_NONBLOCK);
	if(fd < 0)
	{
		perror("open fifo");
		exit(1);
	}
	write(fd, send, strlen(send));
	
	char recv[100];
    read(fd, recv, sizeof(recv));
	printf("read from my_fifo buf=[%s]\n",recv);
#endif

	return 0;
}

一：不指定 O_NONBLOCK(即 open 没有位或 O_NONBLOCK)

1、open 以只读方式打开 FIFO 时，要阻塞到某个进程为写而打开此 FIFO。

2、open 以只写方式打开 FIFO 时，要阻塞到某个进程为读而打开此 FIFO。

二：指定 O_NONBLOCK(即 open 位或 O_NONBLOCK)

1、先以只读方式打开：如果没有进程已经为写而打开一个 FIFO, 只读 open 成功，并且 open 不阻塞。

2、先以只写方式打开：如果没有进程已经为读而打开一个 FIFO，只写 open 将出错返回-1。

3、read、write 读写命名管道中读数据时不阻塞。

4、通信过程中，读进程退出后，写进程向命名管道内写数据时，写进程也会（收到 SIGPIPE 信号）退出。

文章来源:https://blog.csdn.net/qq_45657052/article/details/135291705
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。