#include <sys/types.h>

#include <unistd.h>



pid_t fork(void);
      

fork 調用失敗則返回-1，調用成功的返回值見下面的解釋。我們通過一個例子來理解 fork 是怎樣創建新進程的。

            #include <sys/types.h>

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>



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
      

這個程序的運行過程如下圖所示。

?

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 <http://gnu.org/licenses/gpl.html>

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 <unistd.h>

3	#include <stdio.h>

4	#include <stdlib.h>

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) 提示符下打印消息，而子進程被先前設的斷點打斷了。

用 fork 創建子進程后執行的是和父進程相同的程序（但有可能執行不同的代碼分支），子進程往往要調用一種 exec 函數以執行另一個程序。當進程調用一種 exec 函數時，該進程的用戶空間代碼和數據完全被新程序替換，從新程序的啟動例程開始執行。調用 exec 并不創建新進程，所以調用 exec 前后該進程的id并未改變。

其實有六種以 exec 開頭的函數，統稱 exec 函數：

        #include <unistd.h>



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的函數：

帶有字母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節。這些函數之間的關系如下圖所示。

一個完整的例子：

        #include <unistd.h>

#include <stdlib.h>



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 ]} 。利用這一點可以實現I/O重定向。先看一個簡單的例子，把標準輸入轉成大寫然后打印到標準輸出：

            /* upper.c */

#include <ctype.h>

#include <stdio.h>



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 。

            /* wrapper.c */

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <fcntl.h>



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.
      

一個進程在終止時會關閉所有文件描述符，釋放在用戶空間分配的內存，但它的PCB還保留著，內核在其中保存了一些信息：如果是正常終止則保存著退出狀態，如果是異常終止則保存著導致該進程終止的信號是哪個。這個進程的父進程可以調用 wait 或 waitpid 獲取這些信息，然后徹底清除掉這個進程。我們知道一個進程的退出狀態可以在Shell中用特殊變量 $? 查看，因為Shell是它的父進程，當它終止時Shell調用 wait 或 waitpid 得到它的退出狀態同時徹底清除掉這個進程。

如果一個進程已經終止，但是它的父進程尚未調用 wait 或 waitpid 對它進行清理，這時的進程狀態稱為僵尸（Zombie） 進程。任何進程在剛終止時都是僵尸進程，正常情況下，僵尸進程都立刻被父進程清理了，為了觀察到僵尸進程，我們自己寫一個不正常的程序，父進程 fork 出子進程，子進程終止，而父進程既不終止也不調用 wait 清理子進程：

        #include <unistd.h>

#include <stdlib.h>



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] <defunct>

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?章? 信號 和 第?34?章? 終端、作業控制與守護進程 將會進一步解釋前臺（Foreground） 和后臺（Backgroud） 的概念。

父進程的pid是6130，子進程是僵尸進程，pid是6131， ps 命令顯示僵尸進程的狀態為 Z ，在命令行一欄還顯示 <defunct> 。

如果一個父進程終止，而它的子進程還存在（這些子進程或者仍在運行，或者已經是僵尸進程了），則這些子進程的父進程改為 init 進程。 init 是系統中的一個特殊進程，通常程序文件是 /sbin/init ，進程id是1，在系統啟動時負責啟動各種系統服務，之后就負責清理子進程，只要有子進程終止， init 就會調用 wait 函數清理它。

僵尸進程是不能用 kill 命令清除掉的，因為 kill 命令只是用來終止進程的，而僵尸進程已經終止了。思考一下，用什么辦法可以清除掉僵尸進程？

wait 和 waitpid 函數的原型是：

        #include <sys/types.h>

#include <sys/wait.h>



pid_t wait(int *status);

pid_t waitpid(pid_t pid, int *status, int options);
      

若調用成功則返回清理掉的子進程id，若調用出錯則返回-1。父進程調用 wait 或 waitpid 時可能會：

這兩個函數的區別是：

可見，調用 wait 和 waitpid 不僅可以獲得子進程的終止信息，還可以使父進程阻塞等待子進程終止，起到進程間同步的作用。如果參數 status 不是空指針，則子進程的終止信息通過這個參數傳出，如果只是為了同步而不關心子進程的終止信息，可以將 status 參數指定為 NULL 。

            #include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>



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把數據從用戶空間拷到內核緩沖區，進程2再從內核緩沖區把數據讀走，內核提供的這種機制稱為進程間通信（IPC，InterProcess Communication） 。如下圖所示。

          #include <unistd.h>



int pipe(int filedes[2]);
        

              #include <stdlib.h>

#include <unistd.h>

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

}
            

          $ mkfifo hello

$ ls -l hello

prw-r--r-- 1 akaedu akaedu 0 2008-10-30 10:44 hello
        

          $ 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