APUE读书笔记---进程间通信(IPC)之管道和有名管道（FIFO）

最新推荐文章于 2024-01-29 16:30:22 发布
最新推荐文章于 2024-01-29 16:30:22 发布
阅读量877 收藏 1
点赞数
分类专栏： Linux 环境编程 文章标签： 函数 读书笔记 通信 ipc 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/men_wen/article/details/59131762
版权

APUE读书笔记—进程间通信(IPC)之管道和有名管道（FIFO）

1. 管道

pipe函数可以创建管道，提供一个单向数据流（半双工）。

#include <unistd.h>

int pipe(int pipefd[2]);
//返回值：若成功，返回0，若出错，返回-1
  • 该函数返回两个文件描述符，fd[0]，fd[1]。前者打开来读，后者打开来写。所以管道在用户程序看起来像是一个打开的文件，通过read(fd[0])或者write(fd[1])。向这个文件读写数据其实是在读写内核缓冲区。
  • 调用pipe函数时在内核中开辟一块缓冲区(称为管道)用于通信,它有一个读端一个写端,然后通过pipefd参数传出给用户程序两个文件描述符。
  • 管道作用于有血缘关系的进程之间,先pipe，再通过fork来传递。
  • 管道使用环形队列实现的，数据从写端流入从读端流出。

1.1 管道如何进行通信

这里写图片描述

  • 父进程调用pipe函数在内核中开辟管道，得到两个文件描述符指向管道的两端。
  • 父进程调用fork函数，子进程共享两个文件描述符指向同一管道。
  • 父进程关闭管道读端，子进程关闭管道写端。父进程可以往管道里写，子进程可以从管道里读。

1.2 管道实例

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

int main(void)
{
    int fd[2];
    pid_t pid;
    int len;
    int flag;
    char str[1024] = "hello world\n";
    char buf[1024];

    if(pipe(fd) < 0){
        perror("pipe err"); 
        exit(1);
    }

    //父写子读
    if((pid = fork()) < 0){
        perror("fork err"); 
        exit(1);
    }else if(pid > 0){  //parent
        close(fd[0]);   //关闭父进程读端
        sleep(5);
        write(fd[1], str, strlen(str));
        close(fd[1]);       //写完关闭写端
        wait(NULL);
    }else{      //child
        close(fd[1]);   //关闭子进程写端

        //设置子进程读端为非阻塞，如失败返回EAGAIN
        flag = fcntl(fd[0], F_GETFL);
        flag |= O_NONBLOCK;
        fcntl(fd[0], F_SETFL, flag);

tryagain:
        len = read(fd[0], buf, sizeof(str));

        if(len < 0){
            if(errno == EAGAIN){    //非阻塞读若失败则返回EAGAIN
                write(STDOUT_FILENO, "try again\n", 10);
                sleep(1);
                goto tryagain;
            }else{
                perror("read err"); 
                exit(1);
            }
        }   

        close(fd[0]);       //读完关闭读端
        write(STDOUT_FILENO, buf, len);
    }

    return 0;
}

父进程睡眠5秒后为子进程写数据，子进程每秒尝试读数据，读不到打印出try again，否则打印出读到的数据，运行如下：

try again
try again
try again
try again
try again
hello world

1.3 管道的使用事项

  1. 两个进程通过一个管道只能实现单向通信，如果要实现双向通信必须使用两个管道。
  2. 写端关闭，当读端读完管道的内容，再次读，返回0，相当于读到EOF。
  3. 如果管道写端没关闭，写端暂时无数据，读端读完管道里的数据后再次读，读端会阻塞。
  4. 读端关闭，写端写管道，会产生SIGPIPE信号，写进程默认情况下会终止进程。
  5. 读端没读管道数据，当写端写满管道后，再次写，写端阻塞。

1.4 管道大小

利用fpathconf函数可以查看本机管道大小

#include <stdio.h>
#include <unistd.h>

int main()
{
    int fd[2];
    pipe(fd);
    printf("pipe buf = %ld\n", fpathconf(fd[1], _PC_PIPE_BUF));

    return 0;
}

运行结果：

pipe buf = 4096

2. FIFO有名管道

FIFO是指先进先出（first in first out），它是一个单向数据流（半双工），每个FIFO有一个路径名与之关联，从而允许无亲缘关系的进程访问同一个FIFO。FIFO又称有名管道。

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

int mkfifo(const char *pathname, mode_t mode);
//返回值：若成功，返回0，若出错，返回-1
  • pathname是一个普通的路径名，它是FIFO的名字。
  • mode指定文件权限位。
  • mkfifo函数隐含包含O_CREATE | O_EXCL。也就是说，要么创建一个新的FIFO，要么返回一个EEXIST错误。

2.1 例子：无亲缘关系的客户与服务器

服务器主函数代码 server_main,c
#include "unpipc.h"


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

    //create two FIFO
    if((mkfifo(FIFO1, FILE_MODE) < 0) && (errno != EEXIST))
        sys_err("can't create FIFO1\n");
    if((mkfifo(FIFO2, FILE_MODE) < 0) && (errno != EEXIST)) {
        unlink(FIFO1); 
        sys_err("can't create FIFO2\n");
    }

    readfd = open(FIFO1, O_RDONLY, 0);
    writefd = open(FIFO2, O_WRONLY, 0);

    server(readfd, writefd);

    exit(0);
}
服务器函数代码 server.c
#include "unpipc.h"


void server(int readfd, int writefd)
{
    int fd;
    ssize_t n;
    char buff[MAXLINE + 1];

    //read pathname from ipc channel
    if((n = read(readfd, buff, MAXLINE)) == 0)
        sys_err("end-of-file while reading pathname");
    buff[n] = '\0';

    if((fd = open(buff, O_RDONLY)) < 0) {
        snprintf(buff + n, sizeof(buff) - n, ": can't open, %s\n", strerror(errno)); //tell client error
        n = strlen(buff);
        write(writefd, buff, n);
    } else {
        while((n = read(fd, buff, MAXLINE)) > 0)
            write(writefd, buff, n);
        close(fd);
    }
}
客户端主函数代码 client_main.c
#include "unpipc.h"

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

    writefd = open(FIFO1, O_WRONLY, 0);
    readfd = open(FIFO2, O_RDONLY, 0);

    client(readfd, writefd);

    close(readfd);
    close(writefd);

    unlink(FIFO2);
    unlink(FIFO1);
    exit(0);
客户端函数代码 client.c
#include "unpipc.h"

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    char buff[MAXLINE];

    //read pathname
    fgets(buff, MAXLINE, stdin);    //fgets 会读最后一个‘\n’字节
    len = strlen(buff);
    if(buff[len-1] == '\n')
        len--;  //del newline from fgets

    //write pathname to ipc channel
    write(writefd,  buff, len);

    //read from ipc. write to standard output
    while((n = read(readfd, buff, MAXLINE)) > 0)
        write(STDOUT_FILENO, buff, n);
}
头文件 unpipc.h
#ifndef _UNPIPE_H_
#define _UNPIPE_H_

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

#define MAXLINE 4096
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

#define FIFO1 "/home/menwen/work/APUE/IPC/apue_code/fifo.1"
#define FIFO2 "/home/menwen/work/APUE/IPC/apue_code/fifo.2"


void client(int readfd, int writefd); 
void server(int readfd, int writefd);
void sys_err(char *str);

#endif
出错处理函数代码
//sys_err.c是我自己简单封装的一个出错处理函数
#include "unpipc.h"

void sys_err(char *str)
{
    perror(str); 
    exit(1);
}
  • 编译：
gcc server.c server_main.c unpipc.h sys_err.c -o server
gcc client.c client_main.c unpipc.h -o client
  • 运行：
➜  apue_code ./server & //后台运行服务器端代码
[1] 21581 
➜  apue_code ./client       //在执行客户端代码
/home/menwen/work/APUE/IPC/apue_code/unpipc.h   //输入一个文件的路径，就会通过FIFO得到文件内容如下：正是unpipc.h的内容
#ifndef _UNPIPE_H_
#define _UNPIPE_H_

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

#define MAXLINE 4096
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

#define FIFO1 "/home/menwen/work/APUE/IPC/apue_code/fifo.1"
#define FIFO2 "/home/menwen/work/APUE/IPC/apue_code/fifo.2"


void client(int readfd, int writefd); 
void server(int readfd, int writefd);
void sys_err(char *str);

#endif
[1]  + 21581 done       ./server
APUE读书笔记---System v消息队列
men_wen的博客
03-18 679
APUE读书笔记—System v消息队列1. 概述System V消息队列使用消息队列标识符（message queue identifier）标识，具有足够特权的任何进程都可以往给定队列放置一个消息，具有足够特权的任何进程都可以从一个队列中读出一个消息。在内核中，维护了一个定义在struct msqid_ds { struct ipc_perm msg_perm; //内核给每个IP
APUE读书笔记--POSIX消息队列
men_wen的博客
03-06 655
UNP (Vol2) 读书笔记–POSIX消息队列1. 概述 消息队列可以认为是一个消息链表，有足够的写权限的线程可以往队列中放置消息，有足够的读权限的线程可以从队列中取走消息。 每个消息都是一个记录（record），有一个长度和优先级。 消息队列具有随内核的持续性 随内核持续性：IPC对象一直存在到内核重新自举或显式删除该对象为止。 2. mq_open、mq_close、mq_unlink函数
《APUE》读书笔记-第十五章进程间通信
weixin_34417183的博客
12-23 148
　　进程间通信（IPC）是指能在两个进程间进行数据交换的机制。现代OS都对进程有保护机制，因此两个进程不能直接交换数据,必须通过一定机制来完成。　　IPC的机制的作用：　　（1）一个软件也能更容易跟第三方软件或内核进行配合的集成,或移植.如管道,在shell 下执行 ps –aux | grep bash。　　（2）简化软件结构, 可以把一个软件划分多个进程或线程,通过IPC,集成在一起工作.如消...
APUE_管道
sicofield的专栏
09-11 997
1.引言        管道是UNIX系统IPC的最古老形式，在shell下的表现形式为管道线。每当在管道线中输入一个由shell执行的命令序列时，shell为每一条命令单独创建一进程，然后将前一条命令进程的标准输出用管道与后一条命令的标准输入相连接。管道有两个主要局限： ①管道是半双工的，即数据只能在一个方向上流动。虽然某些系统提供全双工管道但是为了可移植性，不能假定系统提供此功能。
进程间通信（IPC）2 ------ 有名管道
str999_cn的专栏
12-18 330
管道的一个不足之处是没有名字，因此只能在具有亲缘关系的进程之间通信。而“有名管道”与此不同，它提供了一个路径名与之关联，作为一个设备文件存在，即使无亲缘关系的进程之间，只要能访问该路径，也可以通过FIFO进行通信。FIFO总是按照先进先出的原则工作，第一个被写入的数据将首先从管道中读出。       函数原型： #include #include int mkfifo(const char
APUE——IPC_管道，消息队列
weixin_44537992的博客
07-21 393
管道基础知识
APUE笔记-进程间通信
wllinux12138的博客
09-21 213
进程间通信 部分内容参考《Unix网络编程 卷2》 管道 只能在有公共祖先的进程中使用。 实验： 1 #include &lt;stdio.h&gt; ...
进程间通信（IPC）相关知识点
01-14
进程间通信（IPC）是操作系统中一种重要的机制，允许不同进程之间交换信息和协调操作。在Linux系统中，有多种IPC方式，包括信号、管道、命名管道（FIFO）、消息队列、共享内存、信号量和套接字等。下面我们将详细...
Linux应用开发：APUE读书笔记+源码
04-08
压缩包内容包含了第三版APUE读书笔记以及相关训练源码，适用于初学UNIX环境（Linux）应用编程的工程师进行学习，能够帮助工程师更好的上手Linux环境下的应用开发。压缩包中还包含很多文中的示例以及相关笔记注释，...
学习《高级Linux环境编程》读书笔记(APUE读书笔记)
04-23
15. 进程间通信：详细讨论了几种UNIX进程间通信的机制，如管道、协同进程、命名管道（FIFO）、XSIIPC（包括消息队列、共享内存和信号量）以及这些机制在C/S模型中的应用比较。 16. 网络IPC：套接字：最后一章介绍了...
APUE笔记 进程间通信
CSLDBLYDX的专栏
04-24 466
管道 #include int pipe(int fds[2]); fd返回两个文件描述符，fd[0]读，fd[1]写！ 管道是单双工的，只能一端写，另一端读，不能两边同时读写 管道实际上是在，内核中开辟了一个双向队列， 当队列写满（队空）时，继续写（读）管道会阻塞当前进程！ 当写端关闭，继续读时返回EOF 当读端关闭，继续写时候发送SIGPIPE信号，默认关闭进程
[apue] 神奇的 Solaris pipe
Z875983491的专栏
11-27 162
说到 pipe 大家可能都不陌生，经典的pipe调用配合fork进行父子进程通讯，简直就是Unix程序的标配。 然而Solaris上的pipe却和Solaris一样是个奇葩(虽然Solaris前途黯淡，但是不妨碍我们从它里面挖掘一些有价值的东西)， 有着和一般pipe诸多的不同之处，本文就来说说Solaris上神奇的pipe和一般pipe之间的异同。 1.solaris pipe 是全双工...
APUE学习之进程间通信（IPC）（上篇）
最新发布
m0_65292176的博客
01-29 972
本篇文章详细讲解进程间通信（IPC）的几种常见方式：信号、管道、命名管道、命名socket。
APUE FIFO管道
u014325402的博客
01-13 345
FIFO 参考:http://blog.csdn.net/haomcu/article/details/46647843    FIFO 表示的是命名管道，可以在两个不相关进程之间进行通信(注:未命名管道是pipe)。      FIFO 也表示一种文件类型，可以通过S_ISFIFO(stat结构的st_mode成员的编码)宏来测试文件是否是FIFO类型.       创建FIFO
APUE笔记之15章_进程间通信
FinixLei的专栏 (https://github.com/FinixLei)
03-09 361
第15章 进程间通信 进程间通信主要有： 管道（pipe） 有名管道（FIFO） XSI之消息队列 XSI之信号量 XSI之共享存储 POSIX信号量 Socket（16章） UNIX域SOCKET（17章） 1. 管道 管道有2种局限性： 历史上，它们是半双工的 只能在具有公共祖先的2个进程之间使用。 通常，一个管道由一个进程创建，在进程调用fork之后，这个管道就...
APUE学习之----进程通信pipe实现管道
yefengzhichen的博客
12-07 615
一，pipe()介绍 管道的特点： 1.管道是半双工的，即同一时间数据只能从一端流向另一端。试想，如果一个管道从两边同时输入和输出数据，那么管道里的数据就乱了。 2.管道的两端一端作为读端，一端作为写端。 3.管道具有自适应的特点，默认会适应速度比较慢的一方，管道被写满或读空时速度快的一方会自动阻塞。 #include int pipe(int pipefd[2]
APUE读书笔记——高级进程通信（管道）
DrawnBreak
02-24 308
假设我们要将一个文件的数据，通过more程序来显示但不希望建立临时文件， 即先复制整个文件，再用more来展示我们可以把文件的数据塞入一个管道，  more程序（由子进程excel启动）读这些数据，并显示在屏幕上和直接more一个文件有啥区别？？？#include "apue.h" #include &lt;sys/wait.h&gt; #define DEF_PAGER "/bin/more" ...
APUE学习之----进程通信fifo实现管道
yefengzhichen的博客
12-11 513
一.fifo介绍 fifo函数用于创建命名管道，作用与匿名管道相同，不过可以在不同的进程之间使用，相当于对一个普通文件进行读写操作就可以了。 这个管道文件是任何有权限的进程都可以使用的，两端都像操作一个普通文件一样对它进行打开、读写、关闭动作就可以了，只要一端写入数据另一端就可以都出来。 #include #include int mkfifo(const char *pathname
[15]APUE：pipe / FIFO
weixin_30702413的博客
12-21 102
管道 pipe 一、概述 管道(pipe / FIFO)是一种文件，属于 pipefs 文件系统类型，可以使用 read、write、close 等系统调用进行操作 其本质是内核维护了一块缓冲区与管道相关联，对管道的任何操作，都将被内核转换成读写对应的内存缓冲区 只有当所有的写入端描述符均已关闭，且管道中的数据都被读出后，对读端描述符调用 read 才会返回 0 (EOF) 若所有读...
进程间通信七大方式：信号与管道详解
进程间通信（IPC）是操作系统中不同进程间进行数据交换和同步的重要手段，它涉及到多种方法，这里主要讨论的是信号、管道（包括普通管道和命名管道FIFO）以及它们在进程同步中的应用。 1. **信号（Sinal）**： - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值