pipe_fifo

最新推荐文章于 2023-01-04 18:06:25 发布
最新推荐文章于 2023-01-04 18:06:25 发布
阅读量301 收藏
点赞数
分类专栏： 操作系统 文章标签： pipe

https://www.cnblogs.com/meihao1203/p/8443827.html


 

2019年2月27日11:51周三农历 己亥 猪年 正月廿三

[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# mkfifo 1.pipe 2.pipe
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# cat a.c
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
int main(int argc, char** argv)
{
    int fdw = open(argv[1],O_WRONLY);
    printf("fdw=%d\n",fdw);
    write(fdw,"hello",5);
    return 0;
}
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# cat b.c
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
int main(int argc, char** argv)
{
    int fdr = open(argv[1],O_RDONLY);
    printf("fdr=%d\n",fdr);
    char buf[10]="";
    read(fdr,buf,sizeof(buf));
    printf("buf=%s\n",buf);
    return 0;
}
    [root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]#gcc a.c -o a  
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]#gcc b.c -o b 
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# cat makefile   
target:a.c b.c
        gcc a.c -o a   #前面换行必须用tab键，否则报错：makefile:2: *** 遗漏分隔符 。 停止。
        gcc b.c -o b 
#.PHONY:clean
clean:
        rm -f a b
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# make clean
rm -f a b
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# ll
总用量 12
prw-r--r-- 1 root root   0 2月  27 11:20 1.pipe
prw-r--r-- 1 root root   0 2月  27 11:20 2.pipe
-rw-r--r-- 1 root root 221 2月  27 11:34 a.c
-rw-r--r-- 1 root root 276 2月  27 11:36 b.c
-rw-r--r-- 1 root root  70 2月  27 11:49 makefile
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# make
gcc a.c -o a
gcc b.c -o b
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# ll
总用量 36
prw-r--r-- 1 root root    0 2月  27 11:20 1.pipe
prw-r--r-- 1 root root    0 2月  27 11:20 2.pipe
-rwxr-xr-x 1 root root 8610 2月  27 11:50 a
-rw-r--r-- 1 root root  221 2月  27 11:34 a.c
-rwxr-xr-x 1 root root 8609 2月  27 11:50 b
-rw-r--r-- 1 root root  276 2月  27 11:36 b.c
-rw-r--r-- 1 root root   70 2月  27 11:49 makefile
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]#
//如果打开读端，但是没有打开对应的写端，进程会卡住，等待写端打开
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# ./a 1.pipe &
[1] 31969
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# ./b 1.pipe &
[2] 31973
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# 
fdr=3
fdw=3
buf=hello
[1]-  完成                  ./a 1.pipe
[2]+  完成                  ./b 1.pipe
/*************两个进程***********/
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# 
fdw=3
fdr=3
buf=hello
[1]-  完成                  ./b 1.pipe
[2]+  完成                  ./a 1.pipe
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]#
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# cat a.c
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
int main(int argc,char* argv[]){
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int fdw=open(argv[1],O_WRONLY);
        if(-1==fdw){
                perror("open");
                return -1;
        }
        int fdr=open(argv[2],O_RDONLY);
        if(-1==fdr){
                perror("open1");
                return -1;
        }
   //   printf("fdr=%d,fdw=%d\n",fdr,fdw);
        char buf[128];
        while(1){
                bzero(buf,sizeof(buf));
                read(0,buf,sizeof(buf));  //读取标准输入
                write(fdw,buf,strlen(buf)-1); //写入管道,回车不要

                memset(buf,0,sizeof(buf));
                read(fdr,buf,sizeof(buf));  //读取管道
                printf("%s\n",buf);        //把读到的内容写到屏幕
        }
        return 0;
}
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# cat b.c
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
int main(int argc,char* argv[]){
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int fdr=open(argv[1],O_RDONLY);
        if(-1==fdr){
                perror("open");
                return -1;
        }
        int fdw=open(argv[2],O_WRONLY);
        if(-1==fdw){
                perror("open1");
                return -1;
        }
  //    printf("fdr=%d,fdw=%d\n",fdr,fdw);
        char buf[128];
        while(1){
                bzero(buf,sizeof(buf));
                read(fdr,buf,sizeof(buf));//读取管道
                printf("%s\n",buf);

                bzero(buf,sizeof(buf));
                read(0,buf,sizeof(buf));//读取标准输入
                write(fdw,buf,strlen(buf)-1);//写入管道
        }
        return 0;
}
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]#
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# ./a 1.pipe 2.pipe
^C
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# ./b 1.pipe 2.pipe
b_fdr=3,b_fdw=4
adsd
b_buf=adas
b_buf=asdasfa
adsfsdgsdgf
asdaf
sdagfdshgds
b_buf=asfvgvfsdagv
^C
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# cat b.c
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
int main(int argc,char* argv[]){
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int fdr=open(argv[1],O_RDONLY);
        if(-1==fdr){
                perror("open");
                return -1;
        }
        int fdw=open(argv[2],O_WRONLY);
        if(-1==fdw){
                perror("open1");
                return -1;
        }
        printf("b_fdr=%d,b_fdw=%d\n",fdr,fdw);
        char buf[128];
        while(1){
                bzero(buf,sizeof(buf));
                read(fdr,buf,sizeof(buf));//读取管道
                //memmove(buf,"hello a",10);
                printf("b_buf=%s\n",buf);

                bzero(buf,sizeof(buf));
                read(0,buf,sizeof(buf));//读取标准输入
                write(fdw,buf,strlen(buf)-1);//写入管道
        }
        return 0;
}
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]# cat a.c
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
int main(int argc,char* argv[]){
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int fdw=open(argv[1],O_WRONLY);
        if(-1==fdw){
                perror("open");
                return -1;
        }
        int fdr=open(argv[2],O_RDONLY);
        if(-1==fdr){
                perror("open1");
                return -1;
        }
        printf("a_fdr=%d,a_fdw=%d\n",fdr,fdw);
        char buf[128];
        while(1){
                bzero(buf,sizeof(buf));
                read(0,buf,sizeof(buf));  //读取标准输入
               //memmove(buf,"hello b",10);
                write(fdw,buf,strlen(buf)-1); //写入管道,回车不要

                memset(buf,0,sizeof(buf));
                read(fdr,buf,sizeof(buf));  //读取管道
                printf("_buf=%s\n",buf);        //把读到的内容写到屏幕
        }
        return 0;
}
[root@10.67.9.137 /newhome/wuyaoyao/Linux_Bash]#
 

0x1ff
关注
专栏目录
pipe管道详解
08-16
在linux下介绍pipe常见的问题，并以代码的形式展现
6_pipe_fifo
11-21
- 创建FIFO：`mkfifo("fifo_name", permissions)`，其中`fifo_name`是路径名，`permissions`是文件权限。 - 打开FIFO：`open("fifo_name", O_RDONLY)`或`open("fifo_name", O_WRONLY)`，根据需求选择读或写模式。 ...
pipe基本使用
Wite_Chen
01-20 3816
一、基本函数介绍 BOOL CreatePipe( //创建管道 PHANDLE hReadPipe, //管道读数据句柄 PHANDLE hWritePipe, //管道写数据句柄 PLSECURITY_ATTRIBUTES lpPipeAttributes, //安全属性,成员bInhertHandle表示子进程是否可继承 DWORD nSize //管道缓冲区大小，
pipe()函数详解
Orange的博客
10-19 1万+
管道概述 管道也叫无名管道，它是UNIX系统IPC(进程间通信)的最古老形式，所有的UNIX系统都支持这种机制。 无名管道特点 1.半双工，数据在同一时刻只能在一个方向上流动 2.数据只能从管道的一端写入，从另一端读出 3.写入管道的数据遵循先入先从出的规则 4.管道所传送的数据不是无格式的，这要求管道的读出方和写入方必须约定好数据的格式，如多少字节算一个消息 5.管道不是普通的文件，不属于某个文件系统，其只存在于内存中 6.管道在内存中对应一个缓冲区，不同的系统其大小不一定相同 7.从管道读数据是一次性操
pipe函数详解
热门推荐
judgejames的博客
11-19 4万+
pipe函数可用于创建一个管道，以实现进程间的通信。pipe函数的定义如下： pipe函数定义中的fd参数是一个大小为2的一个数组类型的指针。该函数成功时返回0，并将一对打开的文件描述符值填入fd参数指向的数组。失败时返回 -1并设置errno。 通过pipe函数创建的这两个文件描述符 fd[0] 和 fd[1] 分别构成管道的两端，往 fd[1] 写入的数据可以从 fd[0] 读出。并且 fd[1] 一端只能进行写操作，fd[0] 一端只能进行读操作，不能反过来使用。要实
PIPE 使用介绍
chenwh_cn的博客
05-25 2515
文章目录一、pipe 简介二、pipe 代码示例 一、pipe 简介 pipe 也叫无名管道，有如下特点： 半双工，同一时刻数据只能一端操作 数据只能从一端写入，从另一端读出 存储在内存缓冲区，不存储在文件系统中，只能用于父子进程通信 数据一旦从管道中读走，就从管道中释放空间 二、pipe 代码示例 创建无名管道，其中 fd[0] 固定用于读管道，而 fd[1] 固定用于写管道 一般文件 I/O 的函数都可以用来操作管道( lseek() 除外) 默认情况当管道里没有数据时，另一个进程调用 read(
hw4_fifo_fifo_
09-28
标题中的“hw4_fifo_fifo_”可能是指一个与硬件或软件相关的项目作业，其中“fifo”是主题，可能指的是“先进先出”（First In First Out）的数据结构或队列。在计算机科学和IT领域，FIFO是一种重要的概念，尤其在...
fifo.rar_fifo_visual c
09-21
标题中的“fifo.rar_fifo_visual c”表明这是一个关于FIFO（First In First Out，先进先出）协议的项目，使用Visual C++作为开发环境。在IT领域，FIFO是一种常见的数据结构和通信机制，特别是在操作系统、计算机网络...
FIFO.zip_fifo
09-19
1. FIFO_write.c：这是一个C语言编写的源代码文件，实现了向FIFO写入数据的功能。通常，写入FIFO的过程涉及到打开FIFO（以写模式），写入数据，然后关闭FIFO。在这个文件中，开发者可能定义了函数来处理这些操作，并...
管道命令（ pipe ）
weixin_45646245的博客
08-11 1310
管道命令 bash 命令执行的时候，有输出的数据会出现，如果这些数据需要经过几道处理后才能得到我们所想要的格式，那么这个时候管道命令就很有用。 管道命令仅能处理由前面一个命令传来的正确信息，也就是标准输出信息，对于标准错误输出没有直接处理能力。 在每一个管道后边跟的必定是【命令】，且该命令必须要能够接受标准输入的命令才可以，这样的命令才是管道命令。 选取命令：cut、grep 选取命令就是将一段数据经过分析后，取出我们所需要的。 cut： 处理的信息以行为单位 指令格式：【cut -d’分隔字符‘
管道pipe
weixin_38011893的博客
04-01 961
管道是一种最基本的IPC机制，由pipe函数创建。 使用管道需要注意的4种特殊情况。
PIPE接口基本描述
muyiwushui的博客
01-04 5262
PIPE接口
pipe管道—进程通信
weixin_61631200的博客
04-14 1195
1.基本原理 管道是最基本的IPC（InterProcess Communication）进程间通信 我们知道进程有4G的虚拟内存，其中0到3G是独立的进程空间，每个进程不相互通，而3G-4G是公用的内核空间。要实现在进程间传递数据，管道就是利用这公用的内核空间来完成，即利用内核的一块缓冲区 2.基本使用 #incldue<unistd.h> int pipe(int fd[2]); fd返回两个文件描述符fd[0]为读，fd[1]为写。fd[1]的输出是fd[0].
pipe管道的使用
u010653778的专栏
03-14 509
管道通讯是一种简单粗暴的进程间通讯，不言而喻有几个缺点：首先是数据自己读但不能写，二是数据一旦自己读取，就不在管道中存在，不能再次读取，三是由于采用半双工通讯方式，数据只能一个方向流动，四是只有在公共祖先的进程间使用管道。 #include #include #include #include #include void sys_perror(const char *str)
PIPE
lusic01的专栏
11-08 396
必须在 fork中调用pipe(),否则子进程不会继承文件描述符。 两个进程不共享祖先进程，就不能使用pipe。但是可以使用命名管道 int fd[2],nbytes; pid_t pid int *write_fd = &fd[1]; int *read_fd=&fd[0]; result=pipe(fd); if(-1==result) {    
pipe fd泄露
Seek42的专栏
08-23 2075
pipe增加的可能原因
pipe
cw312644167的博客
05-19 542
进程同步 看一下上一节写的调用外部shell的方法。 memset(final_path, 0, sizeof(final_path)); int32_t pid = fork(); if (pid) { while(1); } else { make_clear_abs_path(argv[0], final_path); argv[0] = final_pa...
Oracle Pipelined Table
cosio的专栏
01-09 2152
为了让 PL/SQL 函数返回数据的多个行，必须通过返回一个 REF CURSOR 或一个数据集合来完成。REF CURSOR 的这种情况局限于可以从查询中选择的数据，而整个集合在可以返回前，必须进行具体化。Oracle 9i 通过引入的管道化表函数纠正了后一种情况。表函数是返回整个行的集（通常作为一个集合）的函数，可以直接从 SQL 语句中进行查询，就好像它是一个真正的数据库表一样。管道化表函数
NIO笔记9_管道(Pipe)
zhuzhufxz的博客
04-30 1253
JavaNIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。public class TestPipe { @Test public void test1() throws IOException{ //1. 获取管道 Pipe pipe = Pipe.open(); //2. 将缓冲...
open_fifo_for_read windwos 替代
最新发布
06-09
在 Windows 平台上，可以使用命名管道（Named Pipe）来替代 UNIX/Linux 上的 FIFO（Named Pipe 也可以在 UNIX/Linux 上使用）。Named Pipe 是一种有名的、双向的、命名的、匿名管道。与 FIFO 类似，Named Pipe 也可以用于进程间通信，但与 FIFO 不同的是，Named Pipe 可以在不同的进程之间进行双向通信。 以下是在 Windows 平台上使用 Named Pipe 创建一个读管道的示例代码： ```c++ #include <windows.h> #include <stdio.h> #define BUFFER_SIZE 1024 #define PIPE_NAME "\\\\.\\pipe\\testpipe" int main() { HANDLE hPipe; char buffer[BUFFER_SIZE]; DWORD dwRead; hPipe = CreateNamedPipeA( PIPE_NAME, PIPE_ACCESS_INBOUND, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, BUFFER_SIZE, BUFFER_SIZE, 0, NULL ); if (hPipe == INVALID_HANDLE_VALUE) { printf("CreateNamedPipe failed with error %d\n", GetLastError()); return 1; } while (1) { if (!ConnectNamedPipe(hPipe, NULL)) { printf("ConnectNamedPipe failed with error %d\n", GetLastError()); CloseHandle(hPipe); return 1; } if (ReadFile(hPipe, buffer, BUFFER_SIZE, &dwRead, NULL)) { printf("Read %d bytes: %s\n", dwRead, buffer); } else { printf("ReadFile failed with error %d\n", GetLastError()); } DisconnectNamedPipe(hPipe); } CloseHandle(hPipe); return 0; } ``` 该程序使用 CreateNamedPipeA 函数创建一个命名管道，并在管道上等待客户端连接。当客户端连接成功后，程序使用 ReadFile 函数从管道中读取数据，并输出到控制台。最后，程序使用 DisconnectNamedPipe 函数断开与客户端的连接。 你可以通过编写客户端程序来向该程序发送数据。方法与在 UNIX/Linux 上使用 FIFO 的方式相似，只需要使用 CreateFile、WriteFile、CloseHandle 等函数即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值