linux系统编程之管道（二）：管道读写规则和Pipe Capacity、PIPE_BUF

2023-10-29 12:08
文章标签 linux 系统 编程 规则 管道 读写 pipe capacity buf

本文主要是介绍linux系统编程之管道（二）：管道读写规则和Pipe Capacity、PIPE_BUF，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、当没有数据可读时
O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
示例程序如下：

/*************************************************************************> File Name: process_.c> Author: Simba> Mail: dameng34@163.com> Created Time: Sat 23 Feb 2013 02:34:02 PM CST************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>
#define ERR_EXIT(m) \do { \perror(m); \exit(EXIT_FAILURE); \} while(0)int main(int argc, char *argv[])
{int pipefd[2];if (pipe(pipefd) == -1)ERR_EXIT("pipe error");pid_t pid;pid = fork();if (pid == -1)ERR_EXIT("fork error");if (pid == 0){sleep(3);close(pipefd[0]);write(pipefd[1], "hello", 5);close(pipefd[1]);exit(EXIT_SUCCESS);}close(pipefd[1]);char buf[10] = {0};int flags = fcntl(pipefd[0], F_GETFL);fcntl(pipefd[0], F_SETFL, flags | O_NONBLOCK); //enable fd的O_NONBLOCKint ret = read(pipefd[0], buf, 10); //默认是disable fd的O_NONBLOCKif (ret == -1) // 父进程不会阻塞，出错返回ERR_EXIT("read error");printf("buf=%s\n", buf);return 0;
}

特意在子进程中sleep了3s，让父进程先被调度运行，而且读端文件状态标志设置为非阻塞，即立刻出错返回，如下。
simba@ubuntu:~/Documents/code/linux_programming/APUE/pipe$ ./pipe_block
read error: Resource temporarily unavailable

二、当管道满的时候
O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
管道是一块内存缓冲区，可以写个小程序测试一下管道的容量Pipe Capacity：

/*************************************************************************> File Name: process_.c> Author: Simba> Mail: dameng34@163.com> Created Time: Sat 23 Feb 2013 02:34:02 PM CST************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>
#define ERR_EXIT(m) \do { \perror(m); \exit(EXIT_FAILURE); \} while(0)int main(int argc, char *argv[])
{int pipefd[2];if (pipe(pipefd) == -1)ERR_EXIT("pipe error");int ret;int count = 0;int flags = fcntl(pipefd[1], F_GETFL);fcntl(pipefd[1], F_SETFL, flags | O_NONBLOCK); // 设置为非阻塞while (1){ret = write(pipefd[1], "A", 1);if (ret == -1){printf("err=%s\n", strerror(errno));break;}count++;}printf("count=%d\n", count); //管道容量return 0;
}

程序中将写端文件状态标志设置为非阻塞，当管道被写满时不会等待其他进程读取数据，而是直接返回-1并置errno，输出如下：
simba@ubuntu:~/Documents/code/linux_programming/APUE/pipe$ ./pipe_capacity
err=Resource temporarily unavailable
count=65536
打印了错误码，可以看到管道的容量是64kB，man 7 pipe中也有提到在2.6.11内核以前是4096，现在是65536。

三、如果所有管道读端对应的文件描述符被关闭（管道读端的引用计数等于0），则write操作会产生SIGPIPE信号，默认终止当前进程
示例代码如下：

/*************************************************************************> File Name: process_.c> Author: Simba> Mail: dameng34@163.com> Created Time: Sat 23 Feb 2013 02:34:02 PM CST************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>
#define ERR_EXIT(m) \do { \perror(m); \exit(EXIT_FAILURE); \} while(0)void handler(int sig)
{printf("recv sig=%d\n", sig);
}int main(int argc, char *argv[])
{signal(SIGPIPE, handler);int pipefd[2];if (pipe(pipefd) == -1)ERR_EXIT("pipe error");pid_t pid;pid = fork();if (pid == -1)ERR_EXIT("fork error");if (pid == 0){close(pipefd[0]);exit(EXIT_SUCCESS);}close(pipefd[0]);sleep(1);int ret = write(pipefd[1], "hello", 5);if (ret == -1){printf("err=%s\n", strerror(errno));}return 0;
}

输出测试：
simba@ubuntu:~/Documents/code/linux_programming/APUE/pipe$ ./close_fd_read
recv sig=13
err=Broken pipe
父进程睡眠1s确保所有读端文件描述符都已经关闭，如果没有安装SIGPIPE信号的处理函数，则默认终止当前进程，即write函数不会返回，现在write错误返回-1，并置errno=EPIPE，对应的出错信息是Broken pipe。

四、如果所有管道写端对应的文件描述符被关闭（管道写端的引用计数等于0），那么管道中剩余的数据都被读取后，再次read会返回0
示例程序如下：

/*************************************************************************> File Name: process_.c> Author: Simba> Mail: dameng34@163.com> Created Time: Sat 23 Feb 2013 02:34:02 PM CST************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>
#define ERR_EXIT(m) \do { \perror(m); \exit(EXIT_FAILURE); \} while(0)void handler(int sig)
{printf("recv sig=%d\n", sig);
}int main(int argc, char *argv[])
{signal(SIGPIPE, handler);int pipefd[2];if (pipe(pipefd) == -1)ERR_EXIT("pipe error");pid_t pid;pid = fork();if (pid == -1)ERR_EXIT("fork error");if (pid == 0){close(pipefd[1]);exit(EXIT_SUCCESS);}close(pipefd[1]);sleep(1);char buf[10] = {0};int ret = read(pipefd[0], buf, 10);printf("ret = %d\n", ret);return 0;
}

输出测试如下：
simba@ubuntu:~/Documents/code/linux_programming/APUE/pipe$ ./close_fd_write
ret = 0
同样地父进程睡眠1s确保所有的写端文件描述符都已经关闭，read返回0。

五、当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性；当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。
On Linux, PIPE_BUF is 4096 bytes。
The precise semantics depend on whether the file descriptor is nonblocking (O_NONBLOCK), whether there are multiple writers to the pipe, and on n, the number of bytes to be written。即由文件描述符是否是非阻塞的，是否有多个进程向管道写入以及写入的字节数所决定准确的语义，总共分4种情况，具体可man一下。

下面的程序演示 O_NONBLOCK disabled ，size > PIPE_BUF(4K)的情况 ：

/*************************************************************************> File Name: process_.c> Author: Simba> Mail: dameng34@163.com> Created Time: Sat 23 Feb 2013 02:34:02 PM CST************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>
#define ERR_EXIT(m) \do { \perror(m); \exit(EXIT_FAILURE); \} while(0)#define TEST_SIZE 68*1024 // 68KB
/* 默认O_NONBLOCK disabled ，这里验证 size > PIPE_BUF(4K)的情况 */
int main(int argc, char *argv[])
{char a[TEST_SIZE];char b[TEST_SIZE];memset(a, 'A', sizeof(a));memset(b, 'B', sizeof(b));int pipefd[2];int ret = pipe(pipefd);if (ret == -1)ERR_EXIT("pipe error");int pid = fork();if (pid == 0){close(pipefd[0]);ret = write(pipefd[1], a, sizeof(a)); // 全部写完才返回printf("apid=%d write %d bytes to pipe\n", getpid(), ret);exit(0);}pid = fork();if (pid == 0){close(pipefd[0]);ret = write(pipefd[1], b, sizeof(b));printf("bpid=%d write %d bytes to pipe\n", getpid(), ret);exit(0);}close(pipefd[1]);sleep(1);int fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0664);char buf[1024 * 4] = {0};int n = 1;while (1){ret = read(pipefd[0], buf, sizeof(buf)); //当管道被写入数据，就已经可以开始读了,每次读取4kif (ret == 0) // 管道写端全部关闭,即读到了结尾break;printf("n=%02d pid=%d read %d bytes from pipe buf[4095]=%c\n",n++, getpid(), ret, buf[4095]);write(fd, buf, ret);}return 0;
}

输出测试如下：
simba@ubuntu:~/Documents/code/linux_programming/APUE/pipe$ ./pipe_buf
n=01 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=02 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=03 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=04 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=05 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=06 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=07 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=08 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=09 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=10 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=11 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=12 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=13 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=14 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=15 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=16 pid=7137 read 4096 bytes from pipe buf[4095]=B
n=17 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=18 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=19 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=20 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=21 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=22 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=23 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=24 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=25 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=26 pid=7137 read 4096 bytes from pipe buf[4095]=A
apid=7138 write 69632 bytes to pipe
n=27 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=28 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=29 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=30 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=31 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=32 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=33 pid=7137 read 4096 bytes from pipe buf[4095]=A
n=34 pid=7137 read 4096 bytes from pipe buf[4095]=B
bpid=7139 write 69632 bytes to pipe
分析一下：现在的情况是有两个子进程在对管道进行阻塞写入各68k，即每个子进程完全写入68k才返回，而父进程对管道进行阻塞读取，每次读取4k，打印每4k中的最后一个字符，如果没有数据到达就阻塞等待，如果管道剩余数据不足4k，read 很可能返回 < 4k，但因为我们写入68k是4k整数倍，故不存在这种情况。需要注意的是是边写边读，因为前面说过管道的容量只有64k，当管道被写满时子进程就阻塞等待父进程读取后再写入。由上面输出可以看出B进程先写入64k的B，然后A进程写入68k的A之后B进程接着写完最后4K的B，然后write返回。由A进程write完毕输出的提示可知此时A进程已经写完成了，但父进程还没读取A完毕，当两个子进程全部写完退出时关闭写端文件描述符，则父进程read就会返回0，退出while循环。可以得出结论：当多个进程对管道进行写入，且一次性写入数据量大于PIPE_BUF时，则不能保证写入的原子性，即可能数据是穿插着的。man 手册的解释如下：
O_NONBLOCK disabled, n > PIPE_BUF
The write is nonatomic: the data given to write(2) may be interleaved with write(2)s by other process; the write(2) blocks until n bytes have been written.

注意我们这里设定了size=68k，则写端不能设置成非阻塞，因为Pipe Capacity 只有64k，不能一次性写入68k，如果此时管道是满的（64k)，则只能返回-1并置错误码为EAGAIN，且一个字符也不写入，若不是满的，则写入的字节数是不确定的，需要检查write的返回值，而且这些字节很可能也与其他进程写入的数据穿插着。读端也不能设置为非阻塞，如果此时尚未有数据写入（管道为空）则返回-1并置错误码为EAGAIN，如果有部分数据已经写入，则读取的数据字节数也是不确定的，需要检查read的返回值。总之测试4种不同情形下的情况也应设置不同的条件。
O_NONBLOCK disabled, n <= PIPE_BUF
All n bytes are written atomically; write(2) may block if there is not room for n bytes to be written imme‐
diately

   O_NONBLOCK enabled, n <= PIPE_BUFIf  there  is  room  to write n bytes to the pipe, then write(2) succeeds immediately, writing all n bytes;otherwise write(2) fails, with errno set to EAGAIN.O_NONBLOCK disabled, n > PIPE_BUFThe write is nonatomic: the data given to write(2) may be interleaved with write(2)s by other process;  thewrite(2) blocks until n bytes have been written.O_NONBLOCK enabled, n > PIPE_BUFIf  the  pipe  is full, then write(2) fails, with errno set to EAGAIN.  Otherwise, from 1 to n bytes may bewritten (i.e., a "partial write" may occur; the caller should check the return value from write(2)  to  seehow many bytes were actually written), and these bytes may be interleaved with writes by other processes.

管道的前4种读写规则具有普遍意义，Tcp socket 也具有管道的这些特性。

参考：《APUE》
转载自http://blog.csdn.net/jnu_simba/article/details/8952287

这篇关于linux系统编程之管道（二）：管道读写规则和Pipe Capacity、PIPE_BUF的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/300536。

相关文章

Linux中压缩、网络传输与系统监控工具的使用完整指南

Linux中压缩、网络传输与系统监控工具的使用完整指南

《Linux中压缩、网络传输与系统监控工具的使用完整指南》在Linux系统管理中,压缩与传输工具是数据备份和远程协作的桥梁,而系统监控工具则是保障服务器稳定运行的眼睛,下面小编就来和大家详细介绍一下它... 目录引言一、压缩与解压：数据存储与传输的优化核心1. zip/unzip：通用压缩格式的便捷操作2.
阅读更多...
C++20管道运算符的实现示例

C++20管道运算符的实现示例

《C++20管道运算符的实现示例》本文简要介绍C++20管道运算符的使用与实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录标准库的管道运算符使用自己实现类似的管道运算符我们不打算介绍太多，因为它实际属于c++20最为重要的
阅读更多...
Linux中SSH服务配置的全面指南

Linux中SSH服务配置的全面指南

《Linux中SSH服务配置的全面指南》作为网络安全工程师,SSH（SecureShell）服务的安全配置是我们日常工作中不可忽视的重要环节,本文将从基础配置到高级安全加固,全面解析SSH服务的各项参... 目录概述基础配置详解端口与监听设置主机密钥配置认证机制强化禁用密码认证禁止root直接登录实现双因素
阅读更多...
Go语言数据库编程GORM 的基本使用详解

Go语言数据库编程GORM 的基本使用详解

《Go语言数据库编程GORM的基本使用详解》GORM是Go语言流行的ORM框架,封装database/sql,支持自动迁移、关联、事务等,提供CRUD、条件查询、钩子函数、日志等功能,简化数据库操作... 目录一、安装与初始化1. 安装 GORM 及数据库驱动2. 建立数据库连接二、定义模型结构体三、自动迁
阅读更多...
在Linux终端中统计非二进制文件行数的实现方法

在Linux终端中统计非二进制文件行数的实现方法

《在Linux终端中统计非二进制文件行数的实现方法》在Linux系统中,有时需要统计非二进制文件（如CSV、TXT文件）的行数,而不希望手动打开文件进行查看,例如,在处理大型日志文件、数据文件时,了解... 目录在linux终端中统计非二进制文件的行数技术背景实现步骤1. 使用wc命令2. 使用grep命令
阅读更多...
Linux如何快速检查服务器的硬件配置和性能指标

Linux如何快速检查服务器的硬件配置和性能指标

《Linux如何快速检查服务器的硬件配置和性能指标》在运维和开发工作中,我们经常需要快速检查Linux服务器的硬件配置和性能指标,本文将以CentOS为例,介绍如何通过命令行快速获取这些关键信息,... 目录引言一、查询CPU核心数编程（几C？）1. 使用 nproc（最简单）2. 使用 lscpu（详细信
阅读更多...
MySQL主从复制与读写分离的用法解读

MySQL主从复制与读写分离的用法解读

《MySQL主从复制与读写分离的用法解读》：本文主要介绍MySQL主从复制与读写分离的用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、主从复制mysql主从复制原理实验案例二、读写分离实验案例安装并配置mycat 软件设置mycat读写分离验证mycat读
阅读更多...
linux重启命令有哪些? 7个实用的Linux系统重启命令汇总

linux重启命令有哪些? 7个实用的Linux系统重启命令汇总

《linux重启命令有哪些?7个实用的Linux系统重启命令汇总》Linux系统提供了多种重启命令，常用的包括shutdown-r、reboot、init6等，不同命令适用于不同场景，本文将详细... 在管理和维护 linux 服务器时，完成系统更新、故障排查或日常维护后，重启系统往往是必不可少的步骤。本文
阅读更多...
Redis分片集群、数据读写规则问题小结

Redis分片集群、数据读写规则问题小结

《Redis分片集群、数据读写规则问题小结》本文介绍了Redis分片集群的原理,通过数据分片和哈希槽机制解决单机内存限制与写瓶颈问题,实现分布式存储和高并发处理,但存在通信开销大、维护复杂及对事务支持... 目录一、分片集群解android决的问题二、分片集群图解 分片集群特征如何解决的上述问题？（与哨兵模
阅读更多...
Mac系统下卸载JAVA和JDK的步骤

Mac系统下卸载JAVA和JDK的步骤

《Mac系统下卸载JAVA和JDK的步骤》JDK是Java语言的软件开发工具包,它提供了开发和运行Java应用程序所需的工具、库和资源,：本文主要介绍Mac系统下卸载JAVA和JDK的相关资料,需... 目录1. 卸载系统自带的 Java 版本检查当前 Java 版本通过命令卸载系统 Java2. 卸载自定
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2