系统编程之管道篇

最新推荐文章于 2024-12-26 11:10:11 发布
原创 最新推荐文章于 2024-12-26 11:10:11 发布 · 779 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Linux #系统编程 管道

管道（一）

一、

q 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”

q 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道

q 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。

二、匿名管道pipe  

q 包含头文件<unistd.h>

q 功能:创建一无名管道

q 原型

q intpipe(int fd[2]);

q 参数

q fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端

q 返回值:成功返回0，失败返回错误代码

//01pipe.c

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int pipefd[2];

         if (pipe(pipefd) == -1)

                   ERR_EXIT("pipeerror");

 

         pid_t pid;

         pid = fork();

         if (pid == -1)

                   ERR_EXIT("forkerror");

 

         if (pid == 0)

         {

                   close(pipefd[0]);

                   write(pipefd[1],"hello", 5);

                   close(pipefd[1]);

                   exit(EXIT_SUCCESS);

         }

 

         close(pipefd[1]);

         char buf[10] = {0};

         read(pipefd[0], buf, 10);

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

        

         return 0;

 

}

 

//02pipe.c

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int pipefd[2];

         if (pipe(pipefd) == -1)

                   ERR_EXIT("pipeerror");

 

         pid_t pid;

         pid = fork();

         if (pid == -1)

                   ERR_EXIT("forkerror");

 

         if (pid == 0)

         {

                   dup2(pipefd[1],STDOUT_FILENO);

                   close(pipefd[1]);

                   close(pipefd[0]);

                   execlp("ls","ls", NULL);

                   fprintf(stderr, "errorexecute ls\n");

                   exit(EXIT_FAILURE);

         }

 

         dup2(pipefd[0], STDIN_FILENO);

         close(pipefd[0]);

         close(pipefd[1]);

         execlp("wc", "wc","-w", NULL);

         fprintf(stderr, "error executewc\n");

         exit(EXIT_FAILURE);

 

}

 

//03cp.c

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int pipefd[2];

         if (pipe(pipefd) == -1)

                   ERR_EXIT("pipeerror");

 

         pid_t pid;

         pid = fork();

         if (pid == -1)

                   ERR_EXIT("forkerror");

 

         if (pid == 0)

         {

                   dup2(pipefd[1],STDOUT_FILENO);

                   close(pipefd[1]);

                   close(pipefd[0]);

                   execlp("ls","ls", NULL);

                   fprintf(stderr, "errorexecute ls\n");

                   exit(EXIT_FAILURE);

         }

 

         dup2(pipefd[0], STDIN_FILENO);

         close(pipefd[0]);

         close(pipefd[1]);

         execlp("wc", "wc","-w", NULL);

         fprintf(stderr, "error executewc\n");

         exit(EXIT_FAILURE);

 

}

 

管道（二）

一、当没有数据可读时

q O_NONBLOCKdisable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。

q O_NONBLOCKenable：read调用返回-1，errno值为EAGAIN。

 

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int pipefd[2];

         if (pipe(pipefd) == -1)

                   ERR_EXIT("pipeerror");

 

         pid_t pid;

         pid = fork();

         if (pid == -1)

                   ERR_EXIT("forkerror");

 

         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);

         int ret = read(pipefd[0], buf, 10);

         if (ret == -1)

                   ERR_EXIT("readerror");

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

        

         return 0;

 

}

 

 

 

二、当管道满的时候

q O_NONBLOCKdisable： write调用阻塞，直到有进程读走数据

q O_NONBLOCKenable：调用返回-1，errno值为EAGAIN

三、如果所有管道写端对应的文件描述符被关闭，则read返回0

 

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int pipefd[2];

         if (pipe(pipefd) == -1)

                   ERR_EXIT("pipeerror");

 

         pid_t pid;

         pid = fork();

         if (pid == -1)

                   ERR_EXIT("forkerror");

 

         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;

 

}

 

四、如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE

 

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

voidhandler(int sig)

{

         printf("recv a sig=%d\n",sig);

}

 

intmain(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("forkerror");

 

         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("writeerror\n");

        

         return 0;

 

}

 

五、当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。

当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

intmain(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;

}

 

 

 

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<unistd.h>

#include<sys/types.h>

#include<errno.h>

#include<fcntl.h>

 

 

#defineERR_EXIT(m) \

        do \

        { \

                perror(m); \

                exit(EXIT_FAILURE); \

        } while(0)

 

#defineTEST_SIZE 68*1024

 

intmain(void)

{

         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("pipeerror");

 

         pid_t pid;

         pid = fork();

         if (pid == 0)

         {

                   close(pipefd[0]);

                   ret = write(pipefd[1], a,sizeof(a));

                   printf("apid=%d write %dbytes 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 %dbytes to pipe\n", getpid(), ret);

                   exit(0);

         }

 

 

         close(pipefd[1]);

        

         sleep(1);

         int fd = open("test.txt",O_WRONLY | O_CREAT | O_TRUNC, 0644);

         char buf[1024*4] = {0};

         int n = 1;

         while (1)

         {

                   ret = read(pipefd[0], buf,sizeof(buf));

                   if (ret == 0)

                            break;

                   printf("n=%02d pid=%dread %d bytes from pipe buf[4095]=%c\n", n++, getpid(), ret, buf[4095]);

                   write(fd, buf, ret);

 

         }

         return 0; 

}

 

管道（三）

 

一、命名管道

q 管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。

q 如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。

q 命名管道是一种特殊类型的文件

二、创建一个命名管道

q 命名管道可以从命令行上创建，命令行方法是使用下面这个命令：

                            $ mkfifo filename

q 命名管道也可以从程序里创建，相关函数有：

         int mkfifo(const char *filename,mode_tmode);

一、匿名管道与命名管道

q 命名管道可以从命令行上创建，命令行方法是使用下面这个命令：

                            $ mkfifo filename

q 命名管道也可以从程序里创建，相关函数有：

         int mkfifo(const char *filename,mode_tmode);

二、命名管道的打开规则

q 如果当前打开操作是为读而打开FIFO时

q O_NONBLOCKdisable：阻塞直到有相应进程为写而打开该FIFO

q O_NONBLOCKenable：立刻返回成功

q 如果当前打开操作是为写而打开FIFO时

q O_NONBLOCKdisable：阻塞直到有相应进程为读而打开该FIFO

q O_NONBLOCKenable：立刻返回失败，错误码为ENXIO

//02fifor.c

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int fd;

/*     fd = open("p1", O_RDONLY);*/

         fd = open("p1", O_RDONLY |O_NONBLOCK);

        

         if (fd == -1)

                   ERR_EXIT("openerror");

 

         printf("open succ\n");

         return 0;

}

 

//03fifow.c

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include <string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int fd;

         /*fd = open("p1",O_WRONLY);*/

         fd = open("p1", O_WRONLY |O_NONBLOCK);

         if (fd == -1)

                   ERR_EXIT("openerror");

 

         printf("open succ\n");

         return 0;

}

 

三、命名管道示例程序

 

//04fifor.c

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         mkfifo("tp", 0644);

         int infd;

         infd = open("Makefile",O_RDONLY);

         if (infd == -1)

                   ERR_EXIT("open");

        

         int outfd;

         outfd = open("tp", O_WRONLY);

         if (outfd == -1)

                   ERR_EXIT("open");

 

         char buf[1024];

         int n;

         while ((n=read(infd, buf, 1024))>0)

         {

                   write(outfd, buf, n);

         }

         close(infd);

         close(outfd);

         return 0;

}

 

//05fifow.c

#include<unistd.h>

#include<sys/stat.h>

#include<sys/wait.h>

#include<sys/types.h>

#include<fcntl.h>

 

#include<stdlib.h>

#include<stdio.h>

#include<errno.h>

#include<string.h>

#include<signal.h>

#include<sys/time.h>

 

 

#defineERR_EXIT(m) \

         do \

         { \

                   perror(m); \

                   exit(EXIT_FAILURE); \

         } while(0)

 

 

intmain(int argc, char *argv[])

{

         int outfd;

         outfd = open("Makefile2",O_WRONLY | O_CREAT | O_TRUNC, 0644);

         if (outfd == -1)

                   ERR_EXIT("open");

        

         int infd;

         infd = open("tp", O_RDONLY);

         if (outfd == -1)

                   ERR_EXIT("open");

 

         char buf[1024];

         int n;

         while ((n=read(infd, buf, 1024))>0)

         {

                   write(outfd, buf, n);

         }

         close(infd);

         close(outfd);

         unlink("tp");

         return 0;

}

Linux系统编程-进程间通信(管道)
02-18 421
这篇文章介绍Linux下进程的间的通信方式，常用的方式如下:socket—网络通信、管道、文件、消息队列、共享内存、信号量集、信号
Linux系统编程：管道
凯凯在此
08-11 817
文章内容1. 管道简介2. 匿名管道2.1 单工管道 1. 管道简介 匿名管道：一般用于父子进程 FIFO管道/命名管道：一般用于两个独立的进程 通过命令的方式实现管道： 发送文件：send.cpp #include<iostream> using namespace std; int main(int argc,char* argv[]){ for(int i=1;i<argc;++i){ cout << argv[i] &l
linux系统编程之管道（一）：匿名管道和pipe函数
热门推荐
Meditation
05-20 1万+
一、进程间通信 每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。如下图所示。 二、管道是一种最基本的IPC机制，由pipe函
linux系统编程之管道（一）：匿名管道（pipe)
weixin_33701564的博客
07-15 157
一，什么是管道 管道是Linux支持的最初Unix IPC形式之一，具有以下特点： 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道； 只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）； 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独...
linux系统编程-管道
zzyczzyc的博客
10-08 454
管道的概念 管道是一种最基本的IPC（进程间通信）机制，作用于有缘关系的进程间，调用pipe() 即可创建一个管道。它有如下特质：   1. 本质是一个伪文件（实为内核缓冲区）   2. 由两个文件描述符引用，一个表示读，一个表示写   3. 规定数据从管道的写端流入管道，读端流出管道 管道原理：内核使用环形队列，借助内核缓冲区（默认4K）实现。 管道的局限性：   1.数据不能自己读，再...
多进程编程（二）：管道
努力搬砖的打工人
06-25 347
进程间通信：管道
系统编程-管道
m0_71813740的博客
08-25 1341
每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核,在内核中开辟一块。-- 因为无名管道使用范围有限（只能在父子进程之间），为了让任意的两个进程都可以使用管道通信，我们就可以用有名管道.-- 因为我们获取的是文件描述符，所以可以直接使用 read 和 write 函数来进行数据的写入和读取。-- 6 管道是单向的，一边要么读，一边要么写，不可以又读又写，想要一边读一边写，那就创建2个管道。-- 向管道中写数据，从管道中读数据。
文件系统驱动编程基础篇之6——DirectShow.pdf
09-30
它是一个基于组件对象模型(COM)的系统，允许开发者构建复杂媒体处理管道，包括捕获、编辑、播放和记录多媒体数据。在文件系统驱动编程中，了解DirectShow可以帮助开发者更高效地处理与多媒体相关的I/O操作。 首先，...
Linux应用编程-入门篇
06-18
本文将基于"Linux应用编程-入门篇"的标题和描述，深入探讨Linux应用开发的相关知识，帮助零基础的学员快速掌握Linux编程的基础。 首先，我们要理解Linux操作系统的基本概念。Linux是一种自由开放源代码的操作系统，...
LINUX编程基础Shell编程篇
09-09
LINUX编程基础Shell编程篇 Shell编程是Linux编程基础中的一部分，它允许用户通过编写脚本来自动执行复杂的任务。在本节中，我们将学习如何编写Shell脚本，如何赋值和引用变量，如何使用流程控制语句，如何使用IF...
linux系统编程视频教程.zip
最新发布
03-09
第00期为入门篇，是为初学者准备的，旨在帮助他们建立对Linux系统编程的基本概念和理解。随后的第01期到第08期，则分别深入不同的专题，内容逐层深入，难度逐步增加。 第01期课程将带领学习者揭开Linux文件系统的...
linux——管道详解
龙跃十二
03-15 5303
符号表示 | 和管道特别形象。 作用： &nbsp;&nbsp;&nbsp;&nbsp;管道是Linux中很重要的一种通信方式,是把一个程序的输出直接连接到另一个程序的输入,常说的管道多是指无名管道,无名管道只能用于具有亲缘关系的进程之间，这是它与有名管道的最大区别。 有名管道叫named pipe或者FIFO(先进先出)，可以用函数mkfifo()创建。 实现机制 &nb...
linux编程之管道
ajian0051的专栏
01-07 322
管道是linux进程通信的一种方式，还包括信号量，消息队列，socket通信，共享内存等。本文着眼于管道。 管道，就好比水管的两端。数据从一端filedes[0]流入，从另一端filedes[1]流出。 这就需要用到两个进程来做测试，fork可以开辟一对父子进程，用于程序的测试。所以简单说下fork。代码均以最简方式展现。 1.fork fork将使该程序同时开辟一个新的进程，官方的
编程中管道的基本原理和使用
锕琅的博客
08-30 806
管道是进程间用于通信的一种方式。创建管道的进程是管道服务器。连接到管道的进程是管道客户端。一个进程将信息写入管道，然后另一个进程从管道读取信息。本概述介绍如何创建、管理和使用管道。有两种类型的管道：匿名管道和命名管道。匿名管道比命名管道需要更少的开销，但提供的服务有限。术语“管道”通常是指信息管道。从概念上讲，管道有两端。单向管道允许一端的进程向管道写入数据，并允许另一端的进程从管道读取数据。双向管道（或称双工管道）允许进程从管道的任意一端读取和写入。
linux系统编程——管道pipe
春秋繁露
08-10 2695
管道pipe 内核中的缓冲区，多数使用队列（数据结构）来实现的。而队列多采用环形队列，一般采用阻塞机制，还有另一种机制是覆盖机制（当队列满的时候，后入队的覆盖之前的数据）。   下边例1 完成的功能就是 父进程向管道中写数据，子进程读父进程写的数据。 ——例1： /************************************************************
java 编程学习之管道
ceoicac的博客
05-21 534
管道定义的理解 待补充 例子 import java.io.IOException; import java.io.PipedInputStream; import java.io.PipedOutputStream; public class PipeExample { private static PipeExample ourInstance = new PipeE...
Linux系统编程（进程通信--管道）
2301_80394926的博客
12-26 674
管道是。
Linux编程基础 5.1：管道
爱学习爱运动的专栏
05-04 2691
1 简介 Linux进程通信机制： 管道 信号量 消息队列 共享内存 socket通信
Linux 管道的用法
a1534219218的博客
06-04 5180
说明： Linux的管道用于进程间的通信，进程通过PIPE函数，在内核中创建管道，而管道是一个单向队列。 PIPE函数注意： 1. 管道是创建在内存中的，进程结束，空间释放，管道就不存在了 2. 管道中的动心，读完了就删除了，是一个单向队列 3. 如果管道中没有东西可读，会读阻塞 4. 当我们写的内容超过管道的空间时，会产生写阻塞 5. 写管道是fd[1]，读管道是fd[0] ...
Linux管道编程详解与实践
本篇文档是关于Linux管道专题的编程笔记，主要探讨了Linux管道的基本概念、操作以及在实际编程中的应用。Linux管道是Unix系统中最基础的进程间通信方式，通过创建一个数据流连接两个进程，允许数据单向流动。以下是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值