第 30 章 进程
最后更新于：2022-04-01 22:02:07
# 第 30 章 进程
**目录**
+ [1\. 引言](ch30s01.html)
+ [2\. 环境变量](ch30s02.html)
+ [3\. 进程控制](ch30s03.html)
+ [3.1\. fork函数](ch30s03.html#id2866212)
+ [3.2\. exec函数](ch30s03.html#id2866732)
+ [3.3\. wait和waitpid函数](ch30s03.html#id2867242)
+ [4\. 进程间通信](ch30s04.html)
+ [4.1\. 管道](ch30s04.html#id2867812)
+ [4.2\. 其它IPC机制](ch30s04.html#id2868153)
+ [5\. 练习：实现简单的Shell](ch30s05.html)
## 1. 引言
我们知道，每个进程在内核中都有一个进程控制块（PCB）来维护进程相关的信息，Linux内核的进程控制块是`task_struct`结构体。现在我们全面了解一下其中都有哪些信息。
* 进程id。系统中每个进程有唯一的id，在C语言中用`pid_t`类型表示，其实就是一个非负整数。
* 进程的状态，有运行、挂起、停止、僵尸等状态。
* 进程切换时需要保存和恢复的一些CPU寄存器。
* 描述虚拟地址空间的信息。
* 描述控制终端的信息。
* 当前工作目录（Current Working Directory）。
* `umask`掩码。
* 文件描述符表，包含很多指向`file`结构体的指针。
* 和信号相关的信息。
* 用户id和组id。
* 控制终端、Session和进程组。
* 进程可以使用的资源上限（Resource Limit）。
目前读者并不需要理解这些信息的细节，在随后几章中讲到某一项时会再次提醒读者它是保存在PCB中的。
`fork`和`exec`是本章要介绍的两个重要的系统调用。`fork`的作用是根据一个现有的进程复制出一个新进程，原来的进程称为父进程（Parent Process），新进程称为子进程（Child Process）。系统中同时运行着很多进程，这些进程都是从最初只有一个进程开始一个一个复制出来的。在Shell下输入命令可以运行一个程序，是因为Shell进程在读取用户输入的命令之后会调用`fork`复制出一个新的Shell进程，然后新的Shell进程调用`exec`执行新的程序。
我们知道一个程序可以多次加载到内存，成为同时运行的多个进程，例如可以同时开多个终端窗口运行`/bin/bash`，另一方面，一个进程在调用`exec`前后也可以分别执行两个不同的程序，例如在Shell提示符下输入命令`ls`，首先`fork`创建子进程，这时子进程仍在执行`/bin/bash`程序，然后子进程调用`exec`执行新的程序`/bin/ls`，如下图所示。
**图 30.1. fork/exec**
在[第 3 节 “open/close”](ch28s03.html#io.open)中我们做过一个实验：用`umask`命令设置Shell进程的`umask`掩码，然后运行程序`a.out`，结果`a.out`进程的`umask`掩码也和Shell进程一样。现在可以解释了，因为`a.out`进程是Shell进程的子进程，子进程的PCB是根据父进程复制而来的，所以其中的`umask`掩码也和父进程一样。同样道理，子进程的当前工作目录也和父进程一样，所以我们可以用`cd`命令改变Shell进程的当前目录，然后用`ls`命令列出那个目录下的文件，`ls`进程其实是在列自己的当前目录，而不是Shell进程的当前目录，只不过`ls`进程的当前目录正好和Shell进程相同。有一个例外，子进程PCB中的进程id和父进程是不同的。
## 2. 环境变量
先前讲过，`exec`系统调用执行新程序时会把命令行参数和环境变量表传递给`main`函数，它们在整个进程地址空间中的位置如下图所示。
**图 30.2. 进程地址空间**
和命令行参数`argv`类似，环境变量表也是一组字符串，如下图所示。
**图 30.3. 环境变量**
`libc`中定义的全局变量`environ`指向环境变量表，`environ`没有包含在任何头文件中，所以在使用时要用`extern`声明。例如：
**例 30.1. 打印环境变量**
```
#include
int main(void)
{
extern char **environ;
int i;
for(i=0; environ[i]!=NULL; i++)
printf("%s\n", environ[i]);
return 0;
}
```
执行结果为
```
$ ./a.out
SSH_AGENT_PID=5717
SHELL=/bin/bash
DESKTOP_STARTUP_ID=
TERM=xterm
...
```
由于父进程在调用`fork`创建子进程时会把自己的环境变量表也复制给子进程，所以`a.out`打印的环境变量和Shell进程的环境变量是相同的。
按照惯例，环境变量字符串都是`name=value`这样的形式，大多数`name`由大写字母加下划线组成，一般把`name`的部分叫做环境变量，`value`的部分则是环境变量的值。环境变量定义了进程的运行环境，一些比较重要的环境变量的含义如下：
PATH
可执行文件的搜索路径。`ls`命令也是一个程序，执行它不需要提供完整的路径名`/bin/ls`，然而通常我们执行当前目录下的程序`a.out`却需要提供完整的路径名`./a.out`，这是因为`PATH`环境变量的值里面包含了`ls`命令所在的目录`/bin`，却不包含`a.out`所在的目录。`PATH`环境变量的值可以包含多个目录，用`:`号隔开。在Shell中用`echo`命令可以查看这个环境变量的值：
```
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
```
SHELL
当前Shell，它的值通常是`/bin/bash`。
TERM
当前终端类型，在图形界面终端下它的值通常是`xterm`，终端类型决定了一些程序的输出显示方式，比如图形界面终端可以显示汉字，而字符终端一般不行。
LANG
语言和locale，决定了字符编码以及时间、货币等信息的显示格式。
HOME
当前用户主目录的路径，很多程序需要在主目录下保存配置文件，使得每个用户在运行该程序时都有自己的一套配置。
用`environ`指针可以查看所有环境变量字符串，但是不够方便，如果给出`name`要在环境变量表中查找它对应的`value`，可以用`getenv`函数。
```
#include
char *getenv(const char *name);
```
`getenv`的返回值是指向`value`的指针，若未找到则为`NULL`。
修改环境变量可以用以下函数
```
#include
int setenv(const char *name, const char *value, int rewrite);
void unsetenv(const char *name);
```
`putenv`和`setenv`函数若成功则返回为0，若出错则返回非0。
`setenv`将环境变量`name`的值设置为`value`。如果已存在环境变量`name`，那么
* 若rewrite非0，则覆盖原来的定义；
* 若rewrite为0，则不覆盖原来的定义，也不返回错误。
`unsetenv`删除`name`的定义。即使`name`没有定义也不返回错误。
**例 30.2. 修改环境变量**
```
#include
#include
int main(void)
{
printf("PATH=%s\n", getenv("PATH"));
setenv("PATH", "hello", 1);
printf("PATH=%s\n", getenv("PATH"));
return 0;
}
```
```
$ ./a.out
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
PATH=hello
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
```
可以看出，Shell进程的环境变量`PATH`传给了`a.out`，然后`a.out`修改了`PATH`的值，在`a.out`中能打印出修改后的值，但在Shell进程中`PATH`的值没变。父进程在创建子进程时会复制一份环境变量给子进程，但此后二者的环境变量互不影响。
## 3. 进程控制
### 3.1. fork函数
```
#include
#include
pid_t fork(void);
```
`fork`调用失败则返回-1，调用成功的返回值见下面的解释。我们通过一个例子来理解`fork`是怎样创建新进程的。
**例 30.3. fork**
```
#include
#include
#include
#include
int main(void)
{
pid_t pid;
char *message;
int n;
pid = fork();
if (pid < 0) {
perror("fork failed");
exit(1);
}
if (pid == 0) {
message = "This is the child\n";
n = 6;
} else {
message = "This is the parent\n";
n = 3;
}
for(; n > 0; n--) {
printf(message);
sleep(1);
}
return 0;
}
```
```
$ ./a.out
This is the child
This is the parent
This is the child
This is the parent
This is the child
This is the parent
This is the child
$ This is the child
This is the child
```
这个程序的运行过程如下图所示。
**图 30.4. fork**
1. 父进程初始化。
2. 父进程调用`fork`，这是一个系统调用，因此进入内核。
3. 内核根据父进程复制出一个子进程，父进程和子进程的PCB信息相同，用户态代码和数据也相同。因此，_子进程现在的状态看起来和父进程一样，做完了初始化，刚调用了`fork`进入内核，还没有从内核返回_。
4. 现在有两个一模一样的进程看起来都调用了`fork`进入内核等待从内核返回（实际上`fork`只调用了一次），此外系统中还有很多别的进程也等待从内核返回。是父进程先返回还是子进程先返回，还是这两个进程都等待，先去调度执行别的进程，这都不一定，取决于内核的调度算法。
5. 如果某个时刻父进程被调度执行了，从内核返回后就从`fork`函数返回，保存在变量`pid`中的返回值是子进程的id，是一个大于0的整数，因此执下面的`else`分支，然后执行`for`循环，打印`"This is the parent\n"`三次之后终止。
6. 如果某个时刻子进程被调度执行了，从内核返回后就从`fork`函数返回，保存在变量`pid`中的返回值是0，因此执行下面的`if (pid == 0)`分支，然后执行`for`循环，打印`"This is the child\n"`六次之后终止。`fork`调用把父进程的数据复制一份给子进程，但此后二者互不影响，在这个例子中，`fork`调用之后父进程和子进程的变量`message`和`n`被赋予不同的值，互不影响。
7. 父进程每打印一条消息就睡眠1秒，这时内核调度别的进程执行，在1秒这么长的间隙里（对于计算机来说1秒很长了）子进程很有可能被调度到。同样地，子进程每打印一条消息就睡眠1秒，在这1秒期间父进程也很有可能被调度到。所以程序运行的结果基本上是父子进程交替打印，但这也不是一定的，取决于系统中其它进程的运行情况和内核的调度算法，如果系统中其它进程非常繁忙则有可能观察到不同的结果。另外，读者也可以把`sleep(1);`去掉看程序的运行结果如何。
8. 这个程序是在Shell下运行的，因此Shell进程是父进程的父进程。父进程运行时Shell进程处于等待状态（[第 3.3 节 “wait和waitpid函数”](ch30s03.html#process.wait)会讲到这种等待是怎么实现的），当父进程终止时Shell进程认为命令执行结束了，于是打印Shell提示符，而事实上子进程这时还没结束，所以子进程的消息打印到了Shell提示符后面。最后光标停在`This is the child`的下一行，这时用户仍然可以敲命令，即使命令不是紧跟在提示符后面，Shell也能正确读取。
`fork`函数的特点概括起来就是“调用一次，返回两次”，在父进程中调用一次，在父进程和子进程中各返回一次。从上图可以看出，一开始是一个控制流程，调用`fork`之后发生了分叉，变成两个控制流程，这也就是“fork”（分叉）这个名字的由来了。子进程中`fork`的返回值是0，而父进程中`fork`的返回值则是子进程的id（从根本上说`fork`是从内核返回的，内核自有办法让父进程和子进程返回不同的值），这样当`fork`函数返回后，程序员可以根据返回值的不同让父进程和子进程执行不同的代码。
`fork`的返回值这样规定是有道理的。`fork`在子进程中返回0，子进程仍可以调用`getpid`函数得到自己的进程id，也可以调用`getppid`函数得到父进程的id。在父进程中用`getpid`可以得到自己的进程id，然而要想得到子进程的id，只有将`fork`的返回值记录下来，别无它法。
`fork`的另一个特性是所有由父进程打开的描述符都被复制到子进程中。父、子进程中相同编号的文件描述符在内核中指向同一个`file`结构体，也就是说，`file`结构体的引用计数要增加。
用`gdb`调试多进程的程序会遇到困难，`gdb`只能跟踪一个进程（默认是跟踪父进程），而不能同时跟踪多个进程，但可以设置`gdb`在`fork`之后跟踪父进程还是子进程。以上面的程序为例：
```
$ gcc main.c -g
$ gdb a.out
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu"...
(gdb) l
2 #include
3 #include
4 #include
5
6 int main(void)
7 {
8 pid_t pid;
9 char *message;
10 int n;
11 pid = fork();
(gdb)
12 if(pid<0) {
13 perror("fork failed");
14 exit(1);
15 }
16 if(pid==0) {
17 message = "This is the child\n";
18 n = 6;
19 } else {
20 message = "This is the parent\n";
21 n = 3;
(gdb) b 17
Breakpoint 1 at 0x8048481: file main.c, line 17.
(gdb) set follow-fork-mode child
(gdb) r
Starting program: /home/akaedu/a.out
This is the parent
[Switching to process 30725]
Breakpoint 1, main () at main.c:17
17 message = "This is the child\n";
(gdb) This is the parent
This is the parent
```
`set follow-fork-mode child`命令设置`gdb`在`fork`之后跟踪子进程（`set follow-fork-mode parent`则是跟踪父进程），然后用`run`命令，看到的现象是父进程一直在运行，在`(gdb)`提示符下打印消息，而子进程被先前设的断点打断了。
### 3.2. exec函数
用`fork`创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种`exec`函数以执行另一个程序。当进程调用一种`exec`函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用`exec`并不创建新进程，所以调用`exec`前后该进程的id并未改变。
其实有六种以`exec`开头的函数，统称`exec`函数：
```
#include
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);
```
这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回，如果调用出错则返回-1，所以`exec`函数只有出错的返回值而没有成功的返回值。
这些函数原型看起来很容易混，但只要掌握了规律就很好记。不带字母p（表示path）的`exec`函数第一个参数必须是程序的相对路径或绝对路径，例如`"/bin/ls"`或`"./a.out"`，而不能是`"ls"`或`"a.out"`。对于带字母p的函数：
* 如果参数中包含/，则将其视为路径名。
* 否则视为不带路径的程序名，在`PATH`环境变量的目录列表中搜索这个程序。
带有字母l（表示list）的`exec`函数要求将新程序的每个命令行参数都当作一个参数传给它，命令行参数的个数是可变的，因此函数原型中有`...`，`...`中的最后一个可变参数应该是`NULL`，起sentinel的作用。对于带有字母v（表示vector）的函数，则应该先构造一个指向各参数的指针数组，然后将该数组的首地址当作参数传给它，数组中的最后一个指针也应该是`NULL`，就像`main`函数的`argv`参数或者环境变量表一样。
对于以e（表示environment）结尾的`exec`函数，可以把一份新的环境变量表传给它，其他`exec`函数仍使用当前的环境变量表执行新程序。
`exec`调用举例如下：
```
char *const ps_argv[] ={"ps", "-o", "pid,ppid,pgrp,session,tpgid,comm", NULL};
char *const ps_envp[] ={"PATH=/bin:/usr/bin", "TERM=console", NULL};
execl("/bin/ps", "ps", "-o", "pid,ppid,pgrp,session,tpgid,comm", NULL);
execv("/bin/ps", ps_argv);
execle("/bin/ps", "ps", "-o", "pid,ppid,pgrp,session,tpgid,comm", NULL, ps_envp);
execve("/bin/ps", ps_argv, ps_envp);
execlp("ps", "ps", "-o", "pid,ppid,pgrp,session,tpgid,comm", NULL);
execvp("ps", ps_argv);
```
事实上，只有`execve`是真正的系统调用，其它五个函数最终都调用`execve`，所以`execve`在man手册第2节，其它函数在man手册第3节。这些函数之间的关系如下图所示。
**图 30.5. exec函数族**
一个完整的例子：
```
#include
#include
int main(void)
{
execlp("ps", "ps", "-o", "pid,ppid,pgrp,session,tpgid,comm", NULL);
perror("exec ps");
exit(1);
}
```
执行此程序则得到：
```
$ ./a.out
PID PPID PGRP SESS TPGID COMMAND
6614 6608 6614 6614 7199 bash
7199 6614 7199 6614 7199 ps
```
由于`exec`函数只有错误返回值，只要返回了一定是出错了，所以不需要判断它的返回值，直接在后面调用`perror`即可。注意在调用`execlp`时传了两个`"ps"`参数，第一个`"ps"`是程序名，`execlp`函数要在`PATH`环境变量中找到这个程序并执行它，而第二个`"ps"`是第一个命令行参数，`execlp`函数并不关心它的值，只是简单地把它传给`ps`程序，`ps`程序可以通过`main`函数的`argv[0]`取到这个参数。
调用`exec`后，原来打开的文件描述符仍然是打开的[[37](#ftn.id2867112)]。利用这一点可以实现I/O重定向。先看一个简单的例子，把标准输入转成大写然后打印到标准输出：
**例 30.4. upper**
```
/* upper.c */
#include
int main(void)
{
int ch;
while((ch = getchar()) != EOF) {
putchar(toupper(ch));
}
return 0;
}
```
运行结果如下：
```
$ ./upper
hello THERE
HELLO THERE
（按Ctrl-D表示EOF）
$
```
使用Shell重定向：
```
$ cat file.txt
this is the file, file.txt, it is all lower case.
$ ./upper < file.txt
THIS IS THE FILE, FILE.TXT, IT IS ALL LOWER CASE.
```
如果希望把待转换的文件名放在命令行参数中，而不是借助于输入重定向，我们可以利用`upper`程序的现有功能，再写一个包装程序`wrapper`。
**例 30.5. wrapper**
```
/* wrapper.c */
#include
#include
#include
#include
int main(int argc, char *argv[])
{
int fd;
if (argc != 2) {
fputs("usage: wrapper file\n", stderr);
exit(1);
}
fd = open(argv[1], O_RDONLY);
if(fd<0) {
perror("open");
exit(1);
}
dup2(fd, STDIN_FILENO);
close(fd);
execl("./upper", "upper", NULL);
perror("exec ./upper");
exit(1);
}
```
`wrapper`程序将命令行参数当作文件名打开，将标准输入重定向到这个文件，然后调用`exec`执行`upper`程序，这时原来打开的文件描述符仍然是打开的，`upper`程序只负责从标准输入读入字符转成大写，并不关心标准输入对应的是文件还是终端。运行结果如下：
```
$ ./wrapper file.txt
THIS IS THE FILE, FILE.TXT, IT IS ALL LOWER CASE.
```
### 3.3. wait和waitpid函数
一个进程在终止时会关闭所有文件描述符，释放在用户空间分配的内存，但它的PCB还保留着，内核在其中保存了一些信息：如果是正常终止则保存着退出状态，如果是异常终止则保存着导致该进程终止的信号是哪个。这个进程的父进程可以调用`wait`或`waitpid`获取这些信息，然后彻底清除掉这个进程。我们知道一个进程的退出状态可以在Shell中用特殊变量`$?`查看，因为Shell是它的父进程，当它终止时Shell调用`wait`或`waitpid`得到它的退出状态同时彻底清除掉这个进程。
如果一个进程已经终止，但是它的父进程尚未调用`wait`或`waitpid`对它进行清理，这时的进程状态称为僵尸（Zombie）进程。任何进程在刚终止时都是僵尸进程，正常情况下，僵尸进程都立刻被父进程清理了，为了观察到僵尸进程，我们自己写一个不正常的程序，父进程`fork`出子进程，子进程终止，而父进程既不终止也不调用`wait`清理子进程：
```
#include
#include
int main(void)
{
pid_t pid=fork();
if(pid<0) {
perror("fork");
exit(1);
}
if(pid>0) { /* parent */
while(1);
}
/* child */
return 0;
}
```
在后台运行这个程序，然后用`ps`命令查看：
```
$ ./a.out &
[1] 6130
$ ps u
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
akaedu 6016 0.0 0.3 5724 3140 pts/0 Ss 08:41 0:00 bash
akaedu 6130 97.2 0.0 1536 284 pts/0 R 08:44 14:33 ./a.out
akaedu 6131 0.0 0.0 0 0 pts/0 Z 08:44 0:00 [a.out]
akaedu 6163 0.0 0.0 2620 1000 pts/0 R+ 08:59 0:00 ps u
```
在`./a.out`命令后面加个`&`表示后台运行，Shell不等待这个进程终止就立刻打印提示符并等待用户输命令。现在Shell是位于前台的，用户在终端的输入会被Shell读取，后台进程是读不到终端输入的。第二条命令`ps u`是在前台运行的，在此期间Shell进程和`./a.out`进程都在后台运行，等到`ps u`命令结束时Shell进程又重新回到前台。在[第 33 章 _信号_](ch33.html#signal)和[第 34 章 _终端、作业控制与守护进程_](ch34.html#jobs)将会进一步解释前台（Foreground）和后台（Backgroud）的概念。
父进程的pid是6130，子进程是僵尸进程，pid是6131，`ps`命令显示僵尸进程的状态为`Z`，在命令行一栏还显示`<defunct>`。
如果一个父进程终止，而它的子进程还存在（这些子进程或者仍在运行，或者已经是僵尸进程了），则这些子进程的父进程改为`init`进程。`init`是系统中的一个特殊进程，通常程序文件是`/sbin/init`，进程id是1，在系统启动时负责启动各种系统服务，之后就负责清理子进程，只要有子进程终止，`init`就会调用`wait`函数清理它。
僵尸进程是不能用`kill`命令清除掉的，因为`kill`命令只是用来终止进程的，而僵尸进程已经终止了。思考一下，用什么办法可以清除掉僵尸进程？
`wait`和`waitpid`函数的原型是：
```
#include
#include
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
```
若调用成功则返回清理掉的子进程id，若调用出错则返回-1。父进程调用`wait`或`waitpid`时可能会：
* 阻塞（如果它的所有子进程都还在运行）。
* 带子进程的终止信息立即返回（如果一个子进程已终止，正等待父进程读取其终止信息）。
* 出错立即返回（如果它没有任何子进程）。
这两个函数的区别是：
* 如果父进程的所有子进程都还在运行，调用`wait`将使父进程阻塞，而调用`waitpid`时如果在`options`参数中指定`WNOHANG`可以使父进程不阻塞而立即返回0。
* `wait`等待第一个终止的子进程，而`waitpid`可以通过`pid`参数指定等待哪一个子进程。
可见，调用`wait`和`waitpid`不仅可以获得子进程的终止信息，还可以使父进程阻塞等待子进程终止，起到进程间同步的作用。如果参数`status`不是空指针，则子进程的终止信息通过这个参数传出，如果只是为了同步而不关心子进程的终止信息，可以将`status`参数指定为`NULL`。
**例 30.6. waitpid**
```
#include
#include
#include
#include
#include
int main(void)
{
pid_t pid;
pid = fork();
if (pid < 0) {
perror("fork failed");
exit(1);
}
if (pid == 0) {
int i;
for (i = 3; i > 0; i--) {
printf("This is the child\n");
sleep(1);
}
exit(3);
} else {
int stat_val;
waitpid(pid, &stat_val, 0);
if (WIFEXITED(stat_val))
printf("Child exited with code %d\n", WEXITSTATUS(stat_val));
else if (WIFSIGNALED(stat_val))
printf("Child terminated abnormally, signal %d\n", WTERMSIG(stat_val));
}
return 0;
}
```
子进程的终止信息在一个`int`中包含了多个字段，用宏定义可以取出其中的每个字段：如果子进程是正常终止的，`WIFEXITED`取出的字段值非零，`WEXITSTATUS`取出的字段值就是子进程的退出状态；如果子进程是收到信号而异常终止的，`WIFSIGNALED`取出的字段值非零，`WTERMSIG`取出的字段值就是信号的编号。作为练习，请读者从头文件里查一下这些宏做了什么运算，是如何取出字段值的。
#### 习题
1、请读者修改[例 30.6 “waitpid”](ch30s03.html#process.waitpid "例 30.6. waitpid")的代码和实验条件，使它产生“Child terminated abnormally”的输出。
* * *
[[37](#id2867112)] 事实上，在每个文件描述符中有一个close-on-exec标志，如果该标志为1，则调用`exec`时关闭这个文件描述符。该标志默认为0，可以用`fcntl`函数将它置1，本书不讨论该标志为1的情况。
## 4. 进程间通信
每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。如下图所示。
**图 30.6. 进程间通信**
### 4.1. 管道
管道是一种最基本的IPC机制，由`pipe`函数创建：
```
#include
int pipe(int filedes[2]);
```
调用`pipe`函数时在内核中开辟一块缓冲区（称为管道）用于通信，它有一个读端一个写端，然后通过`filedes`参数传出给用户程序两个文件描述符，`filedes[0]`指向管道的读端，`filedes[1]`指向管道的写端（很好记，就像0是标准输入1是标准输出一样）。所以管道在用户程序看起来就像一个打开的文件，通过`read(filedes[0]);`或者`write(filedes[1]);`向这个文件读写数据其实是在读写内核缓冲区。`pipe`函数调用成功返回0，调用失败返回-1。
开辟了管道之后如何实现两个进程间的通信呢？比如可以按下面的步骤通信。
**图 30.7. 管道**
1. 父进程调用`pipe`开辟管道，得到两个文件描述符指向管道的两端。
2. 父进程调用`fork`创建子进程，那么子进程也有两个文件描述符指向同一管道。
3. 父进程关闭管道读端，子进程关闭管道写端。父进程可以往管道里写，子进程可以从管道里读，管道是用环形队列实现的，数据从写端流入从读端流出，这样就实现了进程间通信。
**例 30.7. 管道**
```
#include
#include
#define MAXLINE 80
int main(void)
{
int n;
int fd[2];
pid_t pid;
char line[MAXLINE];
if (pipe(fd) < 0) {
perror("pipe");
exit(1);
}
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
}
if (pid > 0) { /* parent */
close(fd[0]);
write(fd[1], "hello world\n", 12);
wait(NULL);
} else { /* child */
close(fd[1]);
n = read(fd[0], line, MAXLINE);
write(STDOUT_FILENO, line, n);
}
return 0;
}
```
使用管道有一些限制：
* 两个进程通过一个管道只能实现单向通信，比如上面的例子，父进程写子进程读，如果有时候也需要子进程写父进程读，就必须另开一个管道。请读者思考，如果只开一个管道，但是父进程不关闭读端，子进程也不关闭写端，双方都有读端和写端，为什么不能实现双向通信？
* 管道的读写端通过打开的文件描述符来传递，因此要通信的两个进程必须从它们的公共祖先那里继承管道文件描述符。上面的例子是父进程把文件描述符传给子进程之后父子进程之间通信，也可以父进程`fork`两次，把文件描述符传给两个子进程，然后两个子进程之间通信，总之需要通过`fork`传递文件描述符使两个进程都能访问同一管道，它们才能通信。
使用管道需要注意以下4种特殊情况（假设都是阻塞I/O操作，没有设置`O_NONBLOCK`标志）：
1. 如果所有指向管道写端的文件描述符都关闭了（管道写端的引用计数等于0），而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次`read`会返回0，就像读到文件末尾一样。
2. 如果有指向管道写端的文件描述符没关闭（管道写端的引用计数大于0），而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读端读数据，那么管道中剩余的数据都被读取后，再次`read`会阻塞，直到管道中有数据可读了才读取数据并返回。
3. 如果所有指向管道读端的文件描述符都关闭了（管道读端的引用计数等于0），这时有进程向管道的写端`write`，那么该进程会收到信号`SIGPIPE`，通常会导致进程异常终止。在[第 33 章 _信号_](ch33.html#signal)会讲到怎样使`SIGPIPE`信号不终止进程。
4. 如果有指向管道读端的文件描述符没关闭（管道读端的引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次`write`会阻塞，直到管道中有空位置了才写入数据并返回。
管道的这四种特殊情况具有普遍意义。在[第 37 章 _socket编程_](ch37.html#socket)要讲的TCP socket也具有管道的这些特性。
#### 习题
1、在[例 30.7 “管道”](ch30s04.html#process.pipe)中，父进程只用到写端，因而把读端关闭，子进程只用到读端，因而把写端关闭，然后互相通信，不使用的读端或写端必须关闭，请读者想一想如果不关闭会有什么问题。
2、请读者修改[例 30.7 “管道”](ch30s04.html#process.pipe)的代码和实验条件，验证我上面所说的四种特殊情况。
### 4.2. 其它IPC机制
进程间通信必须通过内核提供的通道，而且必须有一种办法在进程中标识内核提供的某个通道，上一节讲的管道是用打开的文件描述符来标识的。如果要互相通信的几个进程没有从公共祖先那里继承文件描述符，它们怎么通信呢？内核提供一条通道不成问题，问题是如何标识这条通道才能使各进程都可以访问它？文件系统中的路径名是全局的，各进程都可以访问，因此可以用文件系统中的路径名来标识一个IPC通道。
FIFO和UNIX Domain Socket这两种IPC机制都是利用文件系统中的特殊文件来标识的。可以用`mkfifo`命令创建一个FIFO文件：
```
$ mkfifo hello
$ ls -l hello
prw-r--r-- 1 akaedu akaedu 0 2008-10-30 10:44 hello
```
FIFO文件在磁盘上没有数据块，仅用来标识内核中的一条通道，各进程可以打开这个文件进行`read`/`write`，实际上是在读写内核通道（根本原因在于这个`file`结构体所指向的`read`、`write`函数和常规文件不一样），这样就实现了进程间通信。UNIX Domain Socket和FIFO的原理类似，也需要一个特殊的socket文件来标识内核中的通道，例如`/var/run`目录下有很多系统服务的socket文件：
```
$ ls -l /var/run/
total 52
srw-rw-rw- 1 root root 0 2008-10-30 00:24 acpid.socket
...
srw-rw-rw- 1 root root 0 2008-10-30 00:25 gdm_socket
...
srw-rw-rw- 1 root root 0 2008-10-30 00:24 sdp
...
srwxr-xr-x 1 root root 0 2008-10-30 00:42 synaptic.socket
```
文件类型s表示socket，这些文件在磁盘上也没有数据块。UNIX Domain Socket是目前最广泛使用的IPC机制，到后面讲socket编程时再详细介绍。
现在把进程之间传递信息的各种途径（包括各种IPC机制）总结如下：
* 父进程通过`fork`可以将打开文件的描述符传递给子进程
* 子进程结束时，父进程调用`wait`可以得到子进程的终止信息
* 几个进程可以在文件系统中读写某个共享文件，也可以通过给文件加锁来实现进程间同步
* 进程之间互发信号，一般使用`SIGUSR1`和`SIGUSR2`实现用户自定义功能
* 管道
* FIFO
* mmap函数，几个进程可以映射同一内存区
* SYS V IPC，以前的SYS V UNIX系统实现的IPC机制，包括消息队列、信号量和共享内存，现在已经基本废弃
* UNIX Domain Socket，目前最广泛使用的IPC机制
## 5. 练习：实现简单的Shell
用讲过的各种C函数实现一个简单的交互式Shell，要求：
1、给出提示符，让用户输入一行命令，识别程序名和参数并调用适当的`exec`函数执行程序，待执行完成后再次给出提示符。
2、识别和处理以下符号：
* 简单的标准输入输出重定向（<和>）：仿照[例 30.5 “wrapper”](ch30s03.html#process.wrapper)，先`dup2`然后`exec`。
* 管道（|）：Shell进程先调用`pipe`创建一对管道描述符，然后`fork`出两个子进程，一个子进程关闭读端，调用`dup2`把写端赋给标准输出，另一个子进程关闭写端，调用`dup2`把读端赋给标准输入，两个子进程分别调用`exec`执行程序，而Shell进程把管道的两端都关闭，调用`wait`等待两个子进程终止。
你的程序应该可以处理以下命令：
○ls△-l△-R○>○file1○
○cat○<○file1○|○wc△-c○>○file1○
○表示零个或多个空格，△表示一个或多个空格
';