linux管道学习

Linux管道学习

知识点：
1. 管道左右的命令是并行执行的，而且是从右向左执行的，因此就需要在执行命令之前先对标准输出流及错误流等各种流进行分析，分析清楚了之后，也就相当于已经制定好了计划（打个比方，就相当于排水管道全部已经铺设完成，只等着各种水流来流动），然后并行启动程序，这里还要强调的是，这里的并行指的是“有依赖关系的并行”，反正大家不要理解成“必须前一条命令执行完毕，出来结果之后才能送给后续的命令接着处理”就可以了。

2. 基本的FD只有3个，即0、1、2，其他的需要手动开启，开启的方法是：exec [3到255之间的数]>&[0到2之间的数]；关闭的方法是：exec num>&-。

3. 还要很清楚子shell的概念，除了bash内建的那些指令之外，其他的指令都相当于先fork再exec，也就是用子shell来执行的，还有shell及其他各种脚本也都是在子shell中执行的（详情请参考《shell编程之shell问答录》）。子shell会继承父shell中已经打开的FD，注意子shell只会知道父shell中开启了哪些FD，但并不会知道父shell中的各个FD是怎样的一个关系，例如究竟是2>&1了呢，还是1>&2了呢，这些信息子shell都是不会知道的。

4. 查看当前打开了哪些FD，有两种方法：ls /proc/$$/fd或者lsof -p $$（观察最后几行即可）

5. 任何一个FD都是指向屏幕的（用ls -l /proc/$$/fd便可以看出它们指向的是同一个设备文件），至于谁是输入谁是输出，是由<和>决定的，和0、1、2没有关系

6. 管道|只接受标准输出流；屏幕回显使用得是标准错误流；s=$(ls no)这种命令也是利用标准输出流；而一条命令的正常输出是从FD1出来，而错误输出是从FD2出来；只不过刚开始时FD1恰好与标准输出流对接，而FD2恰好与标准错误流对接。

7. 任何一条外部命令都需要建立一个子shell，例如ls yes 1>&2;ls no 2>&1;这两条命令之间没有任何联系，它们运行时各自建立的子shell的PID肯定是不同的。

8. 可以把若干条语句放到()中组成一个nested sub-shell（内嵌的子shell），这样就会使得()中的语句执行后的各个流汇总到一起集中处理了，例如(ls yes; ls no) 2>&1，最后的2>&对()里面的两条语句相当于都是有效力的

9. 在<或者>的左侧写FD号，在右侧写&加FD号，但需要强调一点是，对于左侧不写FD号的情况，>默认左侧写了1，而<默认左侧写了0

下面就来将一些例子，可以参考《I/O重定向详解及应用实例》。

首先来说一下我自己理解的有关FD的模型，只有在一条命令里（也就是同一个shell里）才可能有流的各种定向问题，例如exec 2>&3;ls 2>&1;cat file 1>&3;这几条语句之间没有任何关系；而ls no 2>&1 1>&3 3>&2就有关系了，最终导致FD2和FD3均指向了标准输出口，而FD1指向了3口（这里我将各个口依次命名为：标准输入口，标准输出口，错误输出口，3口，4口，5口等等）。说的通俗一点，就是大家头脑中一定要有一个各类水管（FD1、FD2、FD3等等）与各个口对接的模型，只有理解了这一点才能得心应手的玩弄各个流于股掌之间。此外，2>&1的意思是各个口是永远不变的，也就是它们固定，这种操作能影响的仅仅是FD指向谁的问题，含义就是FD2指向FD1所指的那个口，各个FD在没有乱指之前都指向自己对应的口。
下面就一些例子来分析一下：
exec 3>&1;exec 4>&1;((ls yes no 2>&1 1>&3 3>&-;echo 'bacoo' >&4) 3>&1 |egrep \* >file) 4>&1 | grep ba;echo $?;cat file;exec 3>&-;exec 4>&-;
运行结果: 
bacoo
0
ls: 无法访问no: 没有该文件或目录
yes
打开FD3和FD4；FD2指向1口，FD1指向3口，FD3关闭；向4口输出bacoo，从这个括号里流出来三股流（ls的输出流，ls的错误流，echo的输出流），由于该三股流还不能直接和硬件打交道，还得受制于外界对它们的影响，因此这里就不再表现为三股流从哪个口出来，取而代之的是表现为用FD几输出什么东西，对这三股流的统一操作是让其FD3指向1口，这下才彻底定下来了那三股流最后从哪个口出来。

exec 6<> file;
以输入输出方式打开文件file，而且是通过6号通道。
echo "hello" >&6;
echo "world!" >&6;
read -u 6 x;echo $x;#不过这里读不出东西来，因为当前文件指针是在file即将要写入数据的地方，也就是在world!行的下一行，因此读出的是空白，加入file已经有了内容，第一行是aaa，第二行是bbb，那么你再exec 6<> file; read -u 6 x;echo &x;应该可以显示出aaa。

ls 2>&1 1>&3 2>&1;这句话导致FD2指向了标准输出口（FD1在还没有乱指之前所指的地方）；FD1指向了3口（FD3在还没有乱指之前所指的地方）；FD2指向了3口（FD1现在所指的地方）。

大家清楚了>的真正含义之后，再加上我上述所列出的一些注意事项，自己再研究研究《I/O重定向详解及应用实例》中的例子，我想就应该可以理解FD的奥秘了。

现在附上《I/O重定向详解及应用实例》的内容如下：
I/O重定向详解及应用实例 

1、 基本概念（这是理解后面的知识的前提，请务必理解） 

a、 I/O重定向通常与 FD有关，shell的FD通常为10个，即 0～9； 

b、 常用FD有3个，为0（stdin，标准输入）、1（stdout，标准输出）、2（stderr，标准错误输出），默认与keyboard、monitor、monitor有关； 

c、 用 < 来改变读进的数据信道(stdin)，使之从指定的档案读进； 

d、 用 > 来改变送出的数据信道(stdout, stderr)，使之输出到指定的档案； 

e、 0 是 < 的默认值，因此 < 与 0<是一样的；同理，> 与 1> 是一样的； 

f、 在IO重定向 中，stdout 与 stderr 的管道会先准备好，才会从 stdin 读进资料； 

g、 管道“|”(pipe line):上一个命令的 stdout 接到下一个命令的 stdin; 

h、 tee 命令是在不影响原本 I/O 的情况下，将 stdout 复制一份到档案去; 

i、 bash（ksh）执行命令的过程：分析命令－变量求值－命令替代（``和$( )）－重定向－通配符展开－确定路径－执行命令； 

j、 ( ) 将 command group 置于 sub-shell 去执行，也称 nested sub-shell，它有一点非常重要的特性是：继承父shell的Standard input, output, and error plus any other open file descriptors。 

k、 exec 命令：常用来替代当前 shell 并重新启动一个 shell，换句话说，并没有启动子 shell。使用这一命令时任何现有环境都将会被清除。exec 在对文件描述符进行操作的时候，也只有在这时，exec 不会覆盖你当前的 shell 环境。 

2、 基本IO 

cmd > file 把 stdout 重定向到 file 文件中； 

cmd >> file 把 stdout 重定向到 file 文件中(追加)； 

cmd 1> fiel 把 stdout 重定向到 file 文件中； 

cmd > file 2>&1 把 stdout 和 stderr 一起重定向到 file 文件中； 

cmd 2> file 把 stderr 重定向到 file 文件中； 

cmd 2>> file 把 stderr 重定向到 file 文件中(追加)； 

cmd >> file 2>&1 把 stderr 和 stderr 一起重定向到 file 文件中(追加)； 

cmd < file >file2 cmd 命令以 file 文件作为 stdin，以 file2 文件作为 stdout； 

cat <>file 以读写的方式打开 file； 

cmd < file cmd 命令以 file 文件作为 stdin； 

cmd << delimiter Here document，从 stdin 中读入，直至遇到 delimiter 分界符。 

3、 进阶IO 

>&n 使用系统调用 dup (2) 复制文件描述符 n 并把结果用作标准输出； 

<&n 标准输入复制自文件描述符 n； 

<&- 关闭标准输入（键盘）； 

>&- 关闭标准输出； 

n<&- 表示将 n 号输入关闭； 

n>&- 表示将 n 号输出关闭； 

上述所有形式都可以前导一个数字，此时建立的文件描述符由这个数字指定而不是缺省的 0 或 1。如： 

... 2>file 运行一个命令并把错误输出(文件描述符 2)定向到 file。 

... 2>&1 运行一个命令并把它的标准输出和输出合并。(严格的说是通过复制文件描述符 1 来建立文件描述符 2 ，但效果通常是合并了两个流。) 

我 们对 2>&1详细说明一下 ：2>&1 也就是 FD2＝FD1 ，这里并不是说FD2 的值 等于FD1的值，因为 > 是改变送出的数据信道，也就是说把 FD2 的 “数据输出通道” 改为 FD1 的 “数据输出通道”。如果仅仅这样，这个改变好像没有什么作用，因为 FD2 的默认输出和 FD1的默认输出本来都是 monitor，一样的！ 但是，当 FD1 是其他文件，甚至是其他 FD 时，这个就具有特殊的用途了。请大家务必理解这一点。 

exec 0exec 1>outfilename # 打开文件outfilename作为stdout。 

exec 2>errfilename # 打开文件 errfilename作为 stderr。 

exec 0<&- # 关闭 FD0。 

exec 1>&- # 关闭 FD1。 

exec 5>&- # 关闭 FD5。 

问： 如果关闭了 FD0、FD1、FD2，其后果是什么？ 恢复 FD0、FD1、FD2与 关闭FD0、FD1、FD2 有什么区别？代码分别是什么？ 打开了FD3～FD9，我们用完之后，你觉得是将他们关闭还是恢复？ 

下面是提示（例子来源于CU一帖子，忘记出处，来日再补上）： 

exec 6>&2 2>ver command >>dev/null & exec 2>&6 # 恢复 FD2 

4、 简单举例 

a、stdout和stderr都通过管道送给egrep了： 

(ls you no 2>&1;ls yes 2>&1) 2>&1|egrep \* >file (ls you no 2>&1;ls yes 2>&1)|egrep \* >file (ls you no;ls yes) 2>&1|egrep \* >file 

这个例子要注意的就是： 

理 解 命令执行顺序 和 管道“|”：在命令执行前，先要进行重定向的处理，并将把 nested sub-shell 的stdout 接到 egrep 命令的 stdin。 nested sub-shell ，在 ( ) 中的两个命令加上（），可以看作一个命令。其 FD1 已经连接到“|”往egrep送了，当遇到 2>&1时，也就是FD2＝FD1，即FD2同FD1一样，往管道 “|”那边送。 

b、 没有任何东西通过管道送给egrep，全部送往monitor。 (ls you no 2>&1;ls yes 2>&1) >&2|egrep \* >file。虽然在（）里面将 FD2转往FD1，但在（）外，遇到 >&2 ，结果所有的都送到monitor。 请理解： 

(ls you no 2>&1) 1>&2|egrep \* >file ## 送到 monitor ls you no 2>&1 1>&2|egrep \* >file ## 送给 管道 “|” ls you no 1>&2 2>&1|egrep \* >file ## 送到 monitor 

 

5、 中阶例子 

条件： stderr通过管道送给egrep，正确消息仍然送给monitor（不变） 

exec 4>&1;(ls you no 2>&1 1>&4 4>&-;ls yes 2>&1 1>&4 4>&-)|egrep \* >file;exec 4>&- 或者 exec 4>&1;(ls you no;ls yes) 2>&1 1>&4 4>&-|egrep \* >file;exec 4>&- 

如果加两个条件： 

（1）要求cmd1和cmd2并行运行； 

（2）将cmd1的返回值赋给变量 ss。 

则为： 

exec 3>&1;exec 4>&1 ss=$(((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 4>&1) exec 3>&-;exec 4>&- 

说明： 

exec 3>&1;4>&1 建立FD3，是用来将下面ls那条语句（子shell）中的FD1 恢复到正常FD1，即输出到monitor，你可以把FD3看作最初始的FD1的硬盘备份（即输出到monitor）；建立FD4，到时用作保存ls的返 回值（echo $?），你可以将FD4看作你考试时用于存放计算“echo $?”的草稿纸； 

(ls you no 2>&1 1>&3 3>&-;echo $? >&4) 大家还记得前面说的子shell和管道吧。这条命令首先会继承FD0、FD1、FD2、FD3、FD4，它位于管道前，所以在运行命令前会先把子 shell自己的FD1和管道“|”相连。但是我们的条件是stderr通过管道送往egrep，stdout仍然输出到monitor。 于是通过2>&1，先把 子shell的FD1 的管道“送给”FD2，于是子shell中的stderr送往管道“|”；再通过 1>&3，把以前的“硬盘备份”恢复给子shell的FD1，于是子shell中的FD1变成送到monitor了。再通过3> &- ，将3关闭；接着运行echo $? ，本来其输出值应该送往管道的，通过 >&4 ，将 输出 送往 “草稿纸”FD4，留以备用。 

((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 于是，stderr 通过管道送给 egrep ，stdout 送给monitor，但是，还有 FD4，它送到哪去了？ $(((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 4>&1)最后的 4>&1 ，就是把FD4 重定向到 FD1。但由于其输出在 $( )中，其值就赋给变量ss了。最后一行关闭 FD3、FD4。 

6、 高阶例子 

命令 cmd1, cmd2, cmd3, cmd4. 如何利用单向管道完成下列功能： 

1. 所有命令并行执行。 

2. cmd1 和 cmd2 不需要 stdin。 

3. cmd1 和 cmd2 的 stdout 定向到 cmd3 的 stdin。 

4. cmd1 和 cmd2 的 stderr 定向到 cmd4 的 stdin。 

5. cmd3 的 stdout 定向到文件 a, stderr 定向到屏幕。 

6. cmd4 的 stdout 定向到文件 b, stderr 定向到屏幕。 

7. cmd1 的返回码赋给变量 s。 

8. 不能利用临时文件。 

解决方法： 

exec 3>&1; exec 4>&1 s=$(((((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 | cmd3 >a 2>&3 ) 2>&1 | cmd4 >b ) 4>&1) exec 3>&-; exec 4>&- 

这 个我一步步解释（好复杂，自己感觉看明白了，过一会再看，大脑仍然有几分钟空白～～～，没想到我也能看明白。exec 3>&1; exec 4>&1 前面的例子都有说明了，就是建立FD3 ，给cmd1恢复其FD1用和给cmd3 恢复其FD2用，建立FD4，保存“echo $?”输出值的“草稿纸”。 

第 一对括号：(cmd1 1>&3 ; echo $? >&4 ) 和其后（第一个）管道。在第一个括号（子shell）中，其FD1已经连到 管道中了，所以用 FD3 将 FD1恢复正常，不让他往管道跑；这里的cmd1没有stdin，接着将 cmd1 运行的返回码 保存到 FD4 中。 

第 二对括号：((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 和其后（第二个）管道。前面的 FD1 已经不送给 cmd2了，FD2 默认也不送过来，所以cmd2 也没有stdin ，所以在第二对括号里面：cmd1和cmd2 的stdout、stderr 为默认输出，一直遇到 “3>&1”为止。请注意：“3>&1”，先将第二对括号看出一个命令，他们遇到 第二个管道时，其FD1 连到 管道 “|”，由于“3>&1”的作用，子shell的FD1 送给FD3 使用，所以所有FD3 的输出都 “流往”cmd3，又由于继承关系（继承第一行的命令），FD3实际上就是cmd1和cmd2的stdout，于是“ cmd1 和 cmd2 的 stdout 定向到 cmd3 的 stdin” 

第 三对括号：(((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 | cmd3 >a 2>&3 ) 2>&1 和其后的第三个管道。cmd1 和 cmd2 的 stdout 已经定向到 cmd3 的 stdin，处理之后，cmd3 >a 意味着将其 stdout 送给 a 文件。而2>&3的意思是：恢复cmd3的错误输出为FD3，即送往 monitor。于是“cmd3 的 stdout 定向到文件 a, stderr 定向到屏幕”。如果没有“2>&3”，那么cmd3的错误输出就会干扰cmd1和cmd2的错误输出，所以它是必须的！请注意第三对括号后 的 “2>&1”| ，其子shell的FD1 本来连接着管道“|”，但子shell FD1 慷慨大方，送给了 FD2，于是FD2 连接着管道。还记得前面的 cmd1 和 cmd2 吗？他们的stderr一直没动了。于是在这里，通过管道送给了 第四个命令cmd4 了。即“cmd1 和 cmd2 的 stderr 定向到 cmd4 的 stdin”。后面就比较简单了。cmd4 >b 表示“cmd4 的 stdout 定向到文件 b, stderr 定向到屏幕（默认）” 

第 四对括号：((((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 | cmd3 >a 2>&3 ) 2>&1 | cmd4 >b ) 与其后的 4>&1。四对括号里面的 FD1、FD2都处理完了。但是还记得前面“echo $? >&4”那块“草稿纸”吗？“4>&1”的作用就是“将草稿纸上的内容送给monitor”，但是由于最外面还有 $() 将其“包着”。于是其值赋给变量“s”。

Linux管道

时间: 2010-05-17 / 分类: C/C++语言 / 您是第 37 位浏览者 / 0个评论 发表评论 

管道是Linux中很重要的一种通信方式,是把一个程序的输出直接连接到另一个程序的输入,常说的管道多是指无名管道,无名管道只能用于具有亲缘关系的进程之间，这是它与有名管道的最大区别。

有名管道叫named pipe或者FIFO(先进先出)，可以用函数mkfifo()创建。

Linux管道的实现机制

在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：

· 限制管道的大小。实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节，使得它的大小不象文件那样不加检验地增长。使用单个固定缓冲区也会带来问题，比如在写管道时可能变满，当这种情况发生时，随后对管道的write()调用将默认地被阻塞，等待某些数据被读取，以便腾出足够的空间供write()调用写。

· 读取进程也可能工作得比写进程快。当所有当前进程数据已被读取时，管道变空。当这种情况发生时，一个随后的read()调用将默认地被阻塞，等待某些数据被写入，这解决了read()调用返回文件结束的问题。

注意：从管道读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多的数据。

1. 管道的结构

在 Linux 中，管道的实现并没有使用专门的数据结构，而是借助了文件系统的file结构和VFS的索引节点inode。通过将两个 file 结构指向同一个临时的 VFS 索引节点，而这个 VFS 索引节点又指向一个物理页面而实现的。

2.管道的读写

管道实现的源代码在fs/pipe.c中，在pipe.c中有很多函数，其中有两个函数比较重要，即管道读函数pipe_read()和管道写函数 pipe_wrtie()。管道写函数通过将字节复制到 VFS 索引节点指向的物理内存而写入数据，而管道读函数则通过复制物理内存中的字节而读出数据。当然，内核必须利用一定的机制同步对管道的访问，为此，内核使用了锁、等待队列和信号。

当写进程向管道中写入时，它利用标准的库函数write()，系统根据库函数传递的文件描述符，可找到该文件的 file 结构。file 结构中指定了用来进行写操作的函数（即写入函数）地址，于是，内核调用该函数完成写操作。写入函数在向内存中写入数据之前，必须首先检查 VFS 索引节点中的信息，同时满足如下条件时，才能进行实际的内存复制工作：

·内存中有足够的空间可容纳所有要写入的数据； 

·内存没有被读程序锁定。 

如果同时满足上述条件，写入函数首先锁定内存，然后从写进程的地址空间中复制数据到内存。否则，写入进程就休眠在 VFS 索引节点的等待队列中，接下来，内核将调用调度程序，而调度程序会选择其他进程运行。写入进程实际处于可中断的等待状态，当内存中有足够的空间可以容纳写入数据，或内存被解锁时，读取进程会唤醒写入进程，这时，写入进程将接收到信号。当数据写入内存之后，内存被解锁，而所有休眠在索引节点的读取进程会被唤醒。

管道的读取过程和写入过程类似。但是，进程可以在没有数据或内存被锁定时立即返回错误信息，而不是阻塞该进程，这依赖于文件或管道的打开模式。反之，进程可以休眠在索引节点的等待队列中等待写入进程写入数据。当所有的进程完成了管道操作之后，管道的索引节点被丢弃，而共享数据页也被释放。

因为管道的实现涉及很多文件的操作,因此,当读者学完有关文件系统的内容后来读pipe.c中的代码，你会觉得并不难理解。

Linux 管道的创建和使用都要简单一些，唯一的原因是它需要更少的参数。实现与 Windows 相同的管道创建目标，Linux 和 UNIX 使用下面的代码片段：

　　创建 Linux 命名管道

查看源代码 

打印帮助

1

　　int fd1[2]; 

3

  if(pipe(fd1))  

5

  { printf("pipe() FAILED: errno=%d",errno);  

7

  return 1;  

9

  }

　　Linux 管道对阻塞之前一次写操作的大小有限制。 专门为每个管道所使用的内核级缓冲区确切为 4096 字节。 除非阅读器清空管道，否则一次超过 4K 的写操作将被阻塞。 实际上这算不上什么限制，因为读和写操作是在不同的线程中实现的。

　　Linux 还支持命名管道。对这些数字的早期评论员建议我，为公平起见，应该比较 Linux 的命名管道和 Windows 的命名管道。我写了另一个在 Linux 上使用命名管道的程序。我发现对于 Linux 上命名的和未命名的管道，结果是没有区别。

　　Linux 管道比 Windows 2000 命名管道快很多，而 Windows 2000 命名管道比 Windows XP 命名管道快得多。

例子: 

查看源代码 

打印帮助

01

#include<stdio.h> 

02

#include<unistd.h> 

03

  

04

int main() 

05

{ 

06

int n,fd[2]; // 这里的fd是文件描述符的数组，用于创建管道做准备的 

07

pid_t pid; 

08

char line[100]; 

09

if(pipe(fd)<0) // 创建管道 

10

  printf("pipe create error\n"); 

11

  

12

if((pid=fork())<0) //利用fork()创建新进程 

13

  printf("fork error\n"); 

14

  

15

else if(pid>0){ //这里是父进程，先关闭管道的读出端，然后在管道的写端写入“hello world" 

16

  close(fd[0]); 

17

  write(fd[1],"hello word\n",11); 

18

} 

19

else{ 

20

  close(fd[1]); //这里是子进程，先关闭管道的写入端，然后在管道的读出端读出数据 

21

  n= read(fd[0],line,100); 

22

  write(STDOUT_FILENO,line,n); 

23

} 

24

exit(0); 

25

}

7.1.1 Linux管道的实现机制

在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：

· 限制管道的大小。实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节，使得它的大小不象文件那样不加检验地增长。使用单个固定缓冲区也会带来问题，比如在写管道时可能变满，当这种情况发生时，随后对管道的write()调用将默认地被阻塞，等待某些数据被读取，以便腾出足够的空间供write()调用写。

· 读取进程也可能工作得比写进程快。当所有当前进程数据已被读取时，管道变空。当这种情况发生时，一个随后的read()调用将默认地被阻塞，等待某些数据被写入，这解决了read()调用返回文件结束的问题。

注意：从管道读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多的数据。

1. 管道的结构

     在 Linux 中，管道的实现并没有使用专门的数据结构，而是借助了文件系统的file结构和VFS的索引节点inode。通过将两个 file 结构指向同一个临时的 VFS 索引节点，而这个 VFS 索引节点又指向一个物理页面而实现的。如图 7.1所示。

  

 图7.1  管道结构示意图

图7.1中有两个 file 数据结构，但它们定义文件操作例程地址是不同的，其中一个是向管道中写入数据的例程地址，而另一个是从管道中读出数据的例程地址。这样，用户程序的系统调用仍然是通常的文件操作，而内核却利用这种抽象机制实现了管道这一特殊操作。

2.管道的读写

      管道实现的源代码在fs/pipe.c中，在pipe.c中有很多函数，其中有两个函数比较重要，即管道读函数pipe_read()和管道写函数pipe_wrtie()。管道写函数通过将字节复制到 VFS 索引节点指向的物理内存而写入数据，而管道读函数则通过复制物理内存中的字节而读出数据。当然，内核必须利用一定的机制同步对管道的访问，为此，内核使用了锁、等待队列和信号。

     当写进程向管道中写入时，它利用标准的库函数write()，系统根据库函数传递的文件描述符，可找到该文件的 file 结构。file 结构中指定了用来进行写操作的函数（即写入函数）地址，于是，内核调用该函数完成写操作。写入函数在向内存中写入数据之前，必须首先检查 VFS 索引节点中的信息，同时满足如下条件时，才能进行实际的内存复制工作：

       ·内存中有足够的空间可容纳所有要写入的数据； 

       ·内存没有被读程序锁定。 

如果同时满足上述条件，写入函数首先锁定内存，然后从写进程的地址空间中复制数据到内存。否则，写入进程就休眠在 VFS 索引节点的等待队列中，接下来，内核将调用调度程序，而调度程序会选择其他进程运行。写入进程实际处于可中断的等待状态，当内存中有足够的空间可以容纳写入数据，或内存被解锁时，读取进程会唤醒写入进程，这时，写入进程将接收到信号。当数据写入内存之后，内存被解锁，而所有休眠在索引节点的读取进程会被唤醒。

     管道的读取过程和写入过程类似。但是，进程可以在没有数据或内存被锁定时立即返回错误信息，而不是阻塞该进程，这依赖于文件或管道的打开模式。反之，进程可以休眠在索引节点的等待队列中等待写入进程写入数据。当所有的进程完成了管道操作之后，管道的索引节点被丢弃，而共享数据页也被释放。

   因为管道的实现涉及很多文件的操作,因此,当读者学完有关文件系统的内容后来读pipe.c中的代码，你会觉得并不难理解。