fork

.操作系统对进程的管理,是通过进程表完成的.进程表中的每一个表项,记录的是当前操作系统中一个进程的信息.

.进程在系统的唯一标识是PID,PID是一个从1到32768的正整数,其中1一般是特殊进程init,其它进程从2开始依次编号.当用完32768后,从2重新开始.

.一个称为“程序计数器（program counter, pc）”的寄存器，指出当前占用 CPU的进程要执行的下一条指令的位置

.当分给某个进程的 CPU时间已经用完,操作系统将该进程相关的寄存器的值,保存到该进程在进程表中对应的表项里面,把将要接替这个进程占用 CPU的那个进程的上下文,从进程表中读出,并更新相应的寄存器. 二)fork的一个例子: #include #include #include #include int main() {

pid_t pid; pid=fork(); if(pid<0)

printf(\"error in fork!\"); else if(pid==0)

printf(\"I am the child process,ID is %d\\n\ else

printf(\"I am the parent process,ID is %d\\n\

}

gcc test1.c -o test1 debian:/tmp# ./test1

I am the child process,ID is 2723 I am the parent process,ID is 2722 程序分析: 1)pid=fork(); 先来看看子进程的表现:

操作系统调用fork()函数创建一个新的进程(子进程),并且在进程表中相应为它建立一个新的表项,

此时子进程得到CPU的调度,它的上下文被换入，占据 CPU，操作系统对fork的实现，使得子进程中fork调用返回0

所以在这个进程中pid=0，这个进程继续执行的过程中，if语句中 pid<0不满足，但是pid= =0是true。所以输出i am the child process... 父进程的表现:

操作系统对fork的实现,使这个调用在父进程中返回刚刚创建的子进程的pid(一个正整数),所以下面的if语句中pid<0,

pid==0的两个分支都不会执行。所以输出i am the parent process... 2)对子进程来说,fork返回给它0,但它的pid绝对不会是0,之所以fork返回0给它,是因为它随时可以调用getpid()来获取自己的pid

3)fork之后父子进程除非采用了同步手段,否则不能确定谁先运行,也不能确定谁先结束.认为子进程结束后父进程才从fork返回的,这是不对的,fork不是这样的,vfork才这样。

4)父进程执行了所有的进程,而子进程只执行了fork()后面的程序,这是因为子进程继承了父进程的PC(程序计数器). 三)fork的另一个例子: #include

#include #include int main() {

pid_t pid1; pid_t pid2; pid1 = fork(); pid2 = fork();

printf(\"pid1:%d, pid2:%d\\n\ }

gcc test2.c -o test2 ./test2

pid1:138, pid2:0 pid1:0, pid2:0 pid1:138, pid2:139 pid1:0, pid2:140 程序分析:

1)执行test2时，启动一个进程，设这个进程为P0，PID为xxxxx 2)当执行到pid1 = fork();时，P0启动了一个进程,设这个进程为P1,它的PID为138,暂且不管P1.

3)P0中的fork返回138给pid1,继续执行到pid2 = fork();此时启动另一个新的进程,设为P2，P2的PID为139 ,同样暂且不管P2.

4)P0的第二个fork返回139给p2,最后P0的执行结果为pid1:138, pid2:139

5)再看P2,P2生成时,P0中的pid1=138,所以P2中的pid1继承P0的pid1=138,而作为子进程pid2=0,P2从第二个fork后开始执行, 最后输出pid1:138, pid2:0.

6)回头看P1,P1中第一条fork返回0给pid1,然后接着执行后面的语句.而后面接着的语句是pid2 = fork();执行到这里,P1又产生了一个新进程,设为P3,先不管P3.

7)P1中第二条fork将P3的PID返回给pid2,P3的PID为140,所以P1的pid2=140。P1继续执行后续程序，结束，输出“pid1:0, pid2:140”. 8)P3作为P1的子进程，继承P1中pid1=0，并且第二条fork将0返回给pid2，所以P3最后输出“pid1:0, pid2:0”. 9)所有的进程都执行完毕. 四)vfork与fork的区别 vfork与fork主要有三点区别:

.fork():子进程拷贝父进程的数据段，堆栈段 vfork():子进程与父进程共享数据段

.fork()父子进程的执行次序不确定vfork 保证子进程先运行,在调用 exec 或 exit 之前与父进程数据是共享的,在它调用 exec或 exit 之后父进程才可能被调度运行。

.vfork()保证子进程先运行,在它调用 exec 或 exit 之后父进程才可能被调度运行.如果在调用这两个函数之前子进程依赖于父进程的进一步动作,则会导致死锁。

1)先用fork()进行试验 #include #include int main(void) {

pid_t pid; int count=0;

pid=fork(); count++;

printf(\"count= %d\\n\ return 0; }

分析:

通过上面fork()的说明,这个程序的输出应该是: ./test count= 1 count= 1

2)而将fork()换成vfork()呢,程序如下 #include #include int main(void) {

pid_t pid; int count=0; pid=vfork(); count++;

printf(\"count= %d\\n\ return 0; }

执行结果: ./test count= 1 count= 1

Segmentation fault (core dumped) 分析:

通过将fork()换成vfork(),由于vfork()是共享数据段,为什么结果不是2呢,答案是:

vfork保证子进程先运行,在它调用 exec 或 exit 之后父进程才可能被调度运行.如果在调用这两个函数之前子进程依赖于父进程的进一步动作,则会导致死锁.

3)做最后的修改,在子进程执行时,调用_exit(),程序如下: #include #include #include int main(void) {

pid_t pid; int count=0; pid=vfork(); if(pid==0) { count++; _exit(0); }

else { count++; }

printf(\"count= %d\\n\ return 0; }

执行结果: ./test count= 2

分析:如果子进程中如果没有调用_exit(0),则父进程不可能被执行,在子进程调用exec(),exit()之后父进程才可能被调用. 所以加上_exit(0),使子进程退出,父进程执行.

这样 else 后的语句就会被父进程执行,又因在子进程调用 exec 或 exit 之前与父进程数据是共享的,

所以子进程退出后把父进程的数据段 count 改成1了,子进程退出后,父进程又执行,最终就将count 变成了 2. 五)写拷贝技术

写拷贝或叫做写时拷贝,就是子进程在创建后共享父进程的虚存内存空间,只是在两个进程中某一个进程需要向虚拟内存写入数据时才拷贝相应部分的虚拟内存.

写拷贝的目的是通过消除不必要的复制来提高效率,当运行一个fork进程时,两个进程将尽可能长地共享相同的物理内存,也就是说内核只复制页表入口地址和标记所有写拷贝的页面.

当有一个进程修改内存时,将会引起缺页,这时内核将分配一个新的物理存储页,并在它被修改之前复制该页.

这样对像init,xinetd,sshd这样的进程将非常有用，因为他们的工作也只是调用fork和exec.

六)clone

.clone函数是Linux所特有的,可以用于创建进程和线程,所有可移植代码从来不使用clone系统调用.

.clone是一个复杂的系统调用,它给予应用程序很大的权限,可以控制父进程共享哪些子进程,它可以将一个线程当作一个特定进程,与其父进程共享用户共间.

七)最后的总结:

1)fork()系统调用是创建一个新进程的首选方式,fork的返回值要么是0，要么是非0，父进程与子进程的根本区别在于fork函数的返回值.

2)vfork()系统调用除了能保证用户空间内存不会被复制之外,它与fork几乎是完全相同的.vfork存在的问题是它要求子进程立即调用exec,

而不用修改任何内存,这在真正实现的时候要困难的多,尤其是考虑到exec调用有可能失败.

3)vfork()的出现是为了解决当初fork()浪费用户空间内存的问题,因为在fork()后,很有可能去执行exec(),vfork()的思想就是取消这种复制. 4)现在的所有unix变量都使用一种写拷贝的技术(copy on write)，它使得一个普通的fork调用非常类似于vfork.因此vfork变得没有必要.

fork and vfork

Unix 2009-03-12 16:24:17 阅读278 评论0 字号：大中小 订阅

‘fork()’函数用于从已存在进程中创建一个新进程。新进程称为子进程，而原进程称为父进程。你可以通过检查‘fork()’函数的返回值知道哪个是父进程，哪个是子进程。父进程得到的返回值是子进程的进程号，而子进程则返回0. 知道子进程自父进程继承什么或未继承什么将有助于我们。下面这个名单会因为不同Unix的实现而发生变化，所以或许准确性有了水份。请注意子进程得到的是这些东西的 *拷贝*，不是它们本身。 由子进程自父进程继承到：

     

  

 

    

进程的资格(真实(real)/有效(effective)/已保存(saved) 用户号(UIDs)和组号(GIDs)) 环境(environment) 堆栈 内存

打开文件的描述符(注意对应的文件的位置由父子进程共享， 这会引起含糊情况)

执行时关闭(close-on-exec) 标志 (译者注：close-on-exec标志可通过fnctl()对文件描述符设置，POSIX.1要求所有目录流都必须在exec函数调用时关闭。更详细说明， 参见《UNIX环境高级编程》 W. R. Stevens, 1993, 尤晋元等译(以下简称《高级编程》), 3.13节和8.9节) 信号(signal)控制设定

nice值 (译者注：nice值由nice函数设定，该值表示进程的优先级， 数值越小，优先级越高)

进程调度类别(scheduler class) (译者注：进程调度类别指进程在系统中被调度时所属的类别，不同类别有不同优先级，根据进程调度类别和nice值，进程调度程序可计算出每个进程的全局优先级(Global process prority)，优先级高的进程优先执行) 进程组号

对话期ID(Session ID) (译者注：译文取自《高级编程》，指：进程所属的对话期 (session)ID， 一个对话期包括一个或多个进程组， 更详细说明参见《高级编程》 9.5节) 当前工作目录

根目录 (译者注：根目录不一定是“/”，它可由chroot函数改变) 文件方式创建屏蔽字(file mode creation mask (umask)) (译者注：译文取自《高级编程》，指：创建新文件的缺省屏蔽字) 资源 控制终端

子进程所独有：



进程号

  



   

不同的父进程号(译者注： 即子进程的父进程号与父进程的父进程号不同， 父进程号可由getppid函数得到)

自己的文件描述符和目录流的拷贝(译者注： 目录流由opendir函数创建，因其为顺序读取，顾称“目录流”)

子进程不继承父进程的进程，正文(text)， 数据和其它锁定内存(memory locks) (译者注：锁定内存指被锁定的虚拟内存页，锁定后， 不允许内核将其在必要时换出(page out)， 详细说明参见《The GNU C Library Reference Manual》 2.2版， 1999, 3.4.2节)

在tms结构中的系统时间(译者注：tms结构可由times函数获得， 它保存四个数据用于记录进程使用处理器 (CPU：Central Processing Unit)的时间，包括：用户时间，系统时间， 用户各子进程合计时间，系统各子进程合计时间)

资源使用(resource utilizations)设定为0

阻塞信号集初始化为空集(译者注：原文此处不明确， 译文根据fork函数手册页稍做修改)

不继承由timer_create函数创建的计时器 不继承异步输入和输出

1.1.2. fork函数与vfork函数的区别在哪里？

有些系统有一个系统调用‘vfork()’，它最初被设计成‘fork()’的较少额外支出 (lower-overhead)版本。因为‘fork()’包括拷贝整个进程的地址空间，所以非常 “昂贵”，这个‘vfork()’函数因此被引入。(在3.0BSD中)(译者注：BSD： Berkeley Software Distribution)

*但是*，自从‘vfork()’被引入，‘fork()’的实现方法得到了很大改善，最值得注意的是“写操作时拷贝”(copy-on- write)的引入，它是通过允许父子进程可访问相同物理内存从而伪装(fake)了对进程地址空间的真实拷贝，直到有进程改变内存中数据时才拷贝。这个提高很大程度上抹杀了需要‘vfork()’的理由；事实上，一大部份系统完全丧失了‘vfork()’的原始功能。但为了兼容，它们仍然提供 ‘vfork()’函数调用，但它只是简单地调用‘fork()’，而不试图模拟所有‘vfork()’ 的语义(semantics，译文取自《高级编程》，指定义的内容和做法)。

结论是，试图使用任何‘fork()’和‘vfork()’的不同点是*很*不明智的。事实上，可能使用‘vfork()’根本就是不明智的，除非你确切知道你想*干什么*。 两者的基本区别在于当使用‘vfork()’创建新进程时，父进程将被暂时阻塞，而子进程则可以借用父进程的地址空间。这个奇特状态将持续直到子进程要么退出，要么调用‘execve()’，至此父进程才继续执行。

这意味着一个由‘vfork()’创建的子进程必须小心以免出乎意料地改变父进程的变量。特别的，子进程必须不从包含‘vfork()’调用的函数返回，而且必须不调用‘exit()’(如果它需要退出，它需要使用‘_exit()’；事实上，对于使用正常 ‘fork()’创建的子进程这也是正确的)(译者注：参见1.1.3)

1.1.3. 为何在一个fork的子进程分支中使用_exit函数而不使用exit函数？ ‘exit()’与‘_exit()’有不少区别在使用‘fork()’，特别是‘vfork()’时变得很突出。

‘exit()’与‘_exit()’的基本区别在于前一个调用实施与调用库里用户状态结构 (user-mode constructs)有关的清除工作(clean-up)，而且调用用户自定义的清除程序 (译者注：自定义清除程序由atexit函数定义，可定义多次，并以倒序执行)，相对应，后一个函数只为进程实施内核清除工作。

在由‘fork()’创建的子进程分支里，正常情况下使用‘exit()’是不正确的，这是因为使用它会导致标准输入输出(译者注：stdio: Standard Input Output)的缓冲区被清空两次，而且临时文件被出乎意料的删除(译者注：临时文件由tmpfile函数创建在系统临时目录下，文件名由系统随机生成)。在C++程序中情况会更糟，因为静态目标(static objects)的析构函数(destructors)可以被错误地执行。(还有一些特殊情况，比如守护程序，它们的*父进程*需要调用 ‘_exit()’而不是子进程；适用于绝大多数情况的基本规则是，‘exit()’在每一次进入‘main’函数后只调用一次。)

在由‘vfork()’创建的子进程分支里，‘exit()’的使用将更加危险，因为它将影响 *父*进程的状态。

vfork用于创建一个新进程，而该新进程的目的是exec一个新进程， vfork和fork一样都创建一个子进程，但是它并不将父进程的地址空间

完全复制到子进程中，因为子进程会立即调用exec，于是也就不会存放该地址空间。

。不过在子进程中调用exec或exit之前，他在父进程的空间中运行。

vfork和fork之间的另一个区别是： vfork保证子进程先运行，在她调用exec或exit之后

父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作

，则会导致死锁。

用fork函数创建子进程后，子进程往往要调用一种exec函数以执行另一个程序， 当进程调用一种exec函数时，该进程完全由新程序代换，而新程序则从其main函数

开始执行，因为调用exec并不创建新进程，所以前后的进程id 并未改变，exec只是用

另一个新程序替换了当前进程的正文，数据，堆和栈段。