关于fork（）函数

红枫 · #1

#include <unistd.h>;
#include <sys/types.h>;

main ()
{
pid_t pid;
pid=fork();

if (pid < 0)
printf("error in fork!");
else if (pid == 0)
printf("i am the child process, my process id is %d\n",getpid());
else
printf("i am the parent process, my process id is %d\n",getpid());
}

结果是
[root@localhost c]# ./a.out
i am the child process, my process id is 4286
i am the parent process, my process id is 4285

//我就想不到为什么两行都打印出来了，在我想来，不管pid是多少，都应该只有一行才对
不知道大家有这样的疑惑没

要搞清楚fork的执行过程，就必须先讲清楚操作系统中的“进程(process)”概念。一个进程，主要包含三个元素：

o. 一个可以执行的程序；
o. 和该进程相关联的全部数据（包括变量，内存空间，缓冲区等等）；
o. 程序的执行上下文（execution context）。

不妨简单理解为，一个进程表示的，就是一个可执行程序的一次执行过程中的一个状态。操作系统对进程的管理，典型的情况，是通过进程表完成的。进程表中的每一个表项，记录的是当前操作系统中一个进程的情况。对于单 CPU的情况而言，每一特定时刻只有一个进程占用 CPU，但是系统中可能同时存在多个活动的（等待执行或继续执行的）进程。

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

当分给某个进程的 CPU时间已经用完，操作系统将该进程相关的寄存器的值，保存到该进程在进程表中对应的表项里面；把将要接替这个进程占用 CPU的那个进程的上下文，从进程表中读出，并更新相应的寄存器（这个过程称为“上下文交换(process context switch)”，实际的上下文交换需要涉及到更多的数据，那和fork无关，不再多说，主要要记住程序寄存器pc指出程序当前已经执行到哪里，是进程上下文的重要内容，换出 CPU的进程要保存这个寄存器的值，换入CPU的进程，也要根据进程表中保存的本进程执行上下文信息，更新这个寄存器）。

好了，有这些概念打底，可以说fork了。当你的程序执行到下面的语句：
pid=fork();
操作系统创建一个新的进程（子进程），并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序；上下文和数据，绝大部分就是原进程（父进程）的拷贝，但它们是两个相互独立的进程！此时程序寄存器pc，在父、子进程的上下文中都声称，这个进程目前执行到fork调用即将返回（此时子进程不占有CPU，子进程的pc不是真正保存在寄存器中，而是作为进程上下文保存在进程表中的对应表项内）。问题是怎么返回，在父子进程中就分道扬镳。

父进程继续执行，操作系统对fork的实现，使这个调用在父进程中返回刚刚创建的子进程的pid（一个正整数），所以下面的if语句中pid<0, pid==0的两个分支都不会执行。所以输出i am the parent process...

子进程在之后的某个时候得到调度，它的上下文被换入，占据 CPU，操作系统对fork的实现，使得子进程中fork调用返回0。所以在这个进程（注意这不是父进程了哦，虽然是同一个程序，但是这是同一个程序的另外一次执行，在操作系统中这次执行是由另外一个进程表示的，从执行的角度说和父进程相互独立）中pid=0。这个进程继续执行的过程中，if语句中pid<0不满足，但是pid==0是true。所以输出i am the child process...

我想你比较困惑的就是，为什么看上去程序中互斥的两个分支都被执行了。在一个程序的一次执行中，这当然是不可能的；但是你看到的两行输出是来自两个进程，这两个进程来自同一个程序的两次执行

fork之后，操作系统会复制一个与父进程完全相同的子进程，虽说是父子关系，但是在操作系统看来，他们更像兄弟关系，这2个进程共享代码空间，但是数据空间是互相独立的，子进程数据空间中的内容是父进程的完整拷贝，指令指针也完全相同，但只有一点不同，如果fork成功，子进程中fork的返回值是0，父进程中fork的返回值是子进程的进程号，如果fork不成功，父进程会返回错误。
可以这样想象，2个进程一直同时运行，而且步调一致，在fork之后，他们分别作不同的工作，也就是分岔了。这也是fork为什么叫fork的原因。
至于那一个最先运行，可能与操作系统有关，而且这个问题在实际应用中并不重要，如果需要父子进程协同，可以通过原语的办法解决。
补充一下，fork()函数复制了当前进程的PCB，并向父进程返回了派生子进程的pid。而且根据上面“corand”兄的提示，父子进程并行，打印语句的先后完全看系统的调度算法。打印的内容控制则靠pid变量来控制。因为我们知道fork()向父进程返回了派生子进程的pid，是个正整数；而派生子进程的pid变量并没有被改变。这一区别使得我们看到了他们的不同输出。

//这是网上原贴，不懂可以看看咯

我做如下修改

#include <unistd.h>;
#include <sys/types.h>;

main ()
{
pid_t pid;
printf("fork!"); // printf("fork!\n");
pid=fork();

if (pid < 0)
printf("error in fork!");
else if (pid == 0)
printf("i am the child process, my process id is %d\n",getpid());
else
printf("i am the parent process, my process id is %d\n",getpid());
}

结果是
[root@localhost c]# ./a.out
fork!i am the child process, my process id is 4286
fork!i am the parent process, my process id is 4285

但我改成printf("fork!\n");后，结果是
[root@localhost c]# ./a.out
fork!
i am the child process, my process id is 4286
i am the parent process, my process id is 4285

为什么只有一个fork!打印出来了？上一个为什么有2个？

main()
{
int a;
int pid;
printf("AAAAAAAA");//print 一次；
pid=fork();//重这里开始分为两个
if(pid==0){//在这里定义的变量父进程是不会有的:int b;
printf("ok");}
else if(pid>;0){
printf("is ok\n");//if you want print b;error!but you can print a;
}
printf("BBBBBBB");//父子进程都会打印;

printf("AAAAAAAA");//print 一次；这里会print 2次
如果你将 printf("AAAAAA") 换成 printf("AAAAAA\n") 那么就是只打印一次了.
主要的区别是因为有了一个 \n 回车符号
这就跟Printf的缓冲机制有关了,printf某些内容时,操作系统仅仅是把该内容放到了stdout的缓冲队列里了,并没有实际的写到屏幕上
但是,只要看到有 \n 则会立即刷新stdout,因此就马上能够打印了.
运行了printf("AAAAAA") 后, AAAAAA 仅仅被放到了缓冲里,再运行到fork时,缓冲里面的 AAAAAA 被子进程继承了
因此在子进程度stdout缓冲里面就也有了 AAAAAA.
所以,你最终看到的会是 AAAAAA 被printf了2次!!!!
而运行 printf("AAAAAA\n")后, AAAAAA 被立即打印到了屏幕上,之后fork到的子进程里的stdout缓冲里不会有 AAAAAA 内容
因此你看到的结果会是 AAAAAA 被printf了1次!!!!

//这是好滴例子，我相信大家看后加上前面的理解，也可以懂了

#include <unistd.h>;
#include <sys/types.h>;

main ()
{ int i=5;
pid_t pid;
pid=fork();
for(;i>;0;i--){
if (pid < 0)
printf("error in fork!");
else if (pid == 0)
printf("i am the child process, my process id is %d and i=%d\n",getpid(),i);
else
printf("i am the parent process, my process id is %d and i=%d\n",getpid(),i);
}
}
i am the child process, my process id is 11879 and i=5
i am the child process, my process id is 11879 and i=4
i am the child process, my process id is 11879 and i=3
i am the child process, my process id is 11879 and i=2
i am the child process, my process id is 11879 and i=1
i am the parent process, my process id is 11878 and i=5
i am the parent process, my process id is 11878 and i=4
i am the parent process, my process id is 11878 and i=3
i am the parent process, my process id is 11878 and i=2
i am the parent process, my process id is 11878 and i=1

//也许大家看了这个例子会更好理解滴哟，哈哈

//下面打击看看内部是怎样编译的吧

#include <stdlib.h>
int main(int argc,char** argv)
{
int a;
int pid;
a=0;
pid = fork();
if(pid == 0)
{
a++;
}else
{
a--;
}
return 0;
}

disassem main

Dump of assembler code for function main:

0x08048368 <main+0>: push %ebp

0x08048369 <main+1>: mov %esp,%ebp

0x0804836b <main+3>: sub $0x8,%esp

0x0804836e <main+6>: and $0xfffffff0,%esp

0x08048371 <main+9>: mov $0x0,%eax

0x08048376 <main+14>: add $0xf,%eax

0x08048379 <main+17>: add $0xf,%eax

0x0804837c <main+20>: shr $0x4,%eax

0x0804837f <main+23>: shl $0x4,%eax

0x08048382 <main+26>: sub %eax,%esp

0x08048384 <main+28>: movl $0x0,0xfffffffc(%ebp)

0x0804838b <main+35>: call 0x80482a0 //fork();从下一条指令开始，父子分道扬镳。操作系统通过复制父进程的相关信息创建子进程，父子共用一个代码段，但各有各的数据段。

0x08048390 <main+40>: mov %eax,0xfffffff8(%ebp) //将系统调用fork()的返回值存放到ebp，子进程的返回值是0，父进程为子进程的pid

0x08048393 <main+43>: cmpl $0x0,0xfffffff8(%ebp)//由于子进程的为零所以执行main+49

0x08048397 <main+47>: jne 0x80483a0 <main+56> //父进程为非零所以调到main+56

0x08048399 <main+49>: lea 0xfffffffc(%ebp),%eax

0x0804839c <main+52>: incl (%eax)

0x0804839e <main+54>: jmp 0x80483a5 <main+61>

0x080483a0 <main+56>: lea 0xfffffffc(%ebp),%eax

0x080483a3 <main+59>: decl (%eax)

0x080483a5 <main+61>: mov $0x0,%eax

0x080483aa <main+66>: leave

0x080483ab <main+67>: ret

End of assembler dump.

(gdb)

//这是内部编译的过程

//哈哈，看到这里是不是很想看看原函数的代码了，下面我贴出来。看滴懂就看，看不懂有前面的
理解也足够了

/* $OpenBSD: kern_fork.c,v 1.44 2001/10/14 14:39:03 art Exp $ */

/* $NetBSD: kern_fork.c,v 1.29 1996/02/09 18:59:34 christos Exp $ */

/*

* Copyright (c) 1982, 1986, 1989, 1991, 1993

* The Regents of the University of California. All rights reserved.

* (c) UNIX System Laboratories, Inc.

* All or some portions of this file are derived from material licensed

* to the University of California by American Telephone and Telegraph

* Co. or Unix System Laboratories, Inc. and are reproduced herein with

* the permission of UNIX System Laboratories, Inc.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:

* This product includes software developed by the University of

* California, Berkeley and its contributors.

* 4. Neither the name of the University nor the names of its contributors

* may be used to endorse or promote products derived from this software

* without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

* @(#)kern_fork.c 8.6 (Berkeley) 4/8/94

*/

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/map.h>

#include <sys/filedesc.h>

#include <sys/kernel.h>

#include <sys/malloc.h>

#include <sys/mount.h>

#include <sys/proc.h>

#include <sys/resourcevar.h>

#include <sys/signalvar.h>

#include <sys/vnode.h>

#include <sys/file.h>

#include <sys/acct.h>

#include <sys/ktrace.h>

#include <sys/sched.h>

#include <dev/rndvar.h>

#include <sys/pool.h>

#include <sys/syscallargs.h>

#include <vm/vm.h>

#include <uvm/uvm_extern.h>

#include <uvm/uvm_map.h>

int nprocs = 1; /* process 0 */

int randompid; /* when set to 1, pid's go random */

pid_t lastpid;

struct forkstat forkstat;

/*ARGSUSED*/

int

sys_fork(p, v, retval)

struct proc *p;

void *v;

register_t *retval;

{

return (fork1(p, SIGCHLD, FORK_FORK, NULL, 0, retval));

}

/*ARGSUSED*/

int

sys_vfork(p, v, retval)

struct proc *p;

void *v;

register_t *retval;

{

return (fork1(p, SIGCHLD, FORK_VFORK|FORK_PPWAIT, NULL, 0, retval));

}

int

sys_rfork(p, v, retval)

struct proc *p;

void *v;

register_t *retval;

{

struct sys_rfork_args /* {

syscallarg(int) flags;

} */ *uap = v;

int rforkflags;

int flags;

flags = FORK_RFORK;

rforkflags = SCARG(uap, flags);

if ((rforkflags & RFPROC) == 0)

return (EINVAL);

switch(rforkflags & (RFFDG|RFCFDG)) {

case (RFFDG|RFCFDG):

return EINVAL;

case RFCFDG:

flags |= FORK_CLEANFILES;

break;

case RFFDG:

break;

default:

flags |= FORK_SHAREFILES;

break;

}

if (rforkflags & RFNOWAIT)

flags |= FORK_NOZOMBIE;

if (rforkflags & RFMEM)

flags |= FORK_VMNOSTACK;

return (fork1(p, SIGCHLD, flags, NULL, 0, retval));

}

int

fork1(p1, exitsig, flags, stack, stacksize, retval)

register struct proc *p1;

int exitsig;

int flags;

void *stack;

size_t stacksize;

register_t *retval;

{

struct proc *p2;

uid_t uid;

struct proc *newproc;

struct vmspace *vm;

int count;

static int pidchecked = 0;

vaddr_t uaddr;

int s;

extern void endtsleep __P((void *));

extern void realitexpire __P((void *));

#ifndef RFORK_FDSHARE

/* XXX - Too dangerous right now. */

if (flags & FORK_SHAREFILES) {

return (EOPNOTSUPP);

}

#endif

/*

* Although process entries are dynamically created, we still keep

* a global limit on the maximum number we will create. We reserve

* the last 5 processes to root. The variable nprocs is the current

* number of processes, maxproc is the limit.

*/

uid = p1->p_cred->p_ruid;

if ((nprocs >= maxproc - 5 && uid != 0) || nprocs >= maxproc) {

tablefull("proc");

return (EAGAIN);

}

/*

* Increment the count of procs running with this uid. Don't allow

* a nonprivileged user to exceed their current limit.

*/

count = chgproccnt(uid, 1);

if (uid != 0 && count > p1->p_rlimit[RLIMIT_NPROC].rlim_cur) {

(void)chgproccnt(uid, -1);

return (EAGAIN);

}

/*

* Allocate a pcb and kernel stack for the process

*/

uaddr = uvm_km_valloc(kernel_map, USPACE);

if (uaddr == 0)

return ENOMEM;

/* Allocate new proc. */

newproc = pool_get(&proc_pool, PR_WAITOK);

lastpid++;

if (randompid)

lastpid = PID_MAX;

retry:

/*

* If the process ID prototype has wrapped around,

* restart somewhat above 0, as the low-numbered procs

* tend to include daemons that don't exit.

*/

if (lastpid >= PID_MAX) {

lastpid = arc4random() % PID_MAX;

pidchecked = 0;

}

if (lastpid >= pidchecked) {

int doingzomb = 0;

pidchecked = PID_MAX;

/*

* Scan the active and zombie procs to check whether this pid

* is in use. Remember the lowest pid that's greater

* than lastpid, so we can avoid checking for a while.

*/

p2 = LIST_FIRST(&allproc);

again:

for (; p2 != 0; p2 = LIST_NEXT(p2, p_list)) {

while (p2->p_pid == lastpid ||

p2->p_pgrp->pg_id == lastpid) {

lastpid++;

if (lastpid >= pidchecked)

goto retry;

}

if (p2->p_pid > lastpid && pidchecked > p2->p_pid)

pidchecked = p2->p_pid;

if (p2->p_pgrp->pg_id > lastpid &&

pidchecked > p2->p_pgrp->pg_id)

pidchecked = p2->p_pgrp->pg_id;

}

if (!doingzomb) {

doingzomb = 1;

p2 = LIST_FIRST(&zombproc);

goto again;

}

}

nprocs++;

p2 = newproc;

p2->p_stat = SIDL; /* protect against others */

p2->p_pid = lastpid;

p2->p_exitsig = exitsig;

LIST_INSERT_HEAD(&allproc, p2, p_list);

p2->p_forw = p2->p_back = NULL; /* shouldn't be necessary */

LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);

/*

* Make a proc table entry for the new process.

* Start by zeroing the section of proc that is zero-initialized,

* then copy the section that is copied directly from the parent.

*/

bzero(&p2->p_startzero,

(unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero));
bcopy(&p1->p_startcopy, &p2->p_startcopy,

(unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));

/*

* Initialize the timeouts.

*/

timeout_set(&p2->p_sleep_to, endtsleep, p2);

timeout_set(&p2->p_realit_to, realitexpire, p2);

/*

* Duplicate sub-structures as needed.

* Increase reference counts on shared objects.

* The p_stats and p_sigacts substructs are set in vm_fork.

*/

p2->p_flag = P_INMEM;

p2->p_emul = p1->p_emul;

if (p1->p_flag & P_PROFIL)

startprofclock(p2);

p2->p_flag |= (p1->p_flag & (P_SUGID | P_SUGIDEXEC));

MALLOC(p2->p_cred, struct pcred *, sizeof(struct pcred),

M_SUBPROC, M_WAITOK);

bcopy(p1->p_cred, p2->p_cred, sizeof(*p2->p_cred));

p2->p_cred->p_refcnt = 1;

crhold(p1->p_ucred);

/* bump references to the text vnode (for procfs) */

p2->p_textvp = p1->p_textvp;

if (p2->p_textvp)

VREF(p2->p_textvp);

if (flags & FORK_CLEANFILES)

p2->p_fd = fdinit(p1);

else if (flags & FORK_SHAREFILES)

p2->p_fd = fdshare(p1);

else

p2->p_fd = fdcopy(p1);

/*

* If p_limit is still copy-on-write, bump refcnt,

* otherwise get a copy that won't be modified.

* (If PL_SHAREMOD is clear, the structure is shared

* copy-on-write.)

*/

if (p1->p_limit->p_lflags & PL_SHAREMOD)

p2->p_limit = limcopy(p1->p_limit);

else {

p2->p_limit = p1->p_limit;

p2->p_limit->p_refcnt++;

}

if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)

p2->p_flag |= P_CONTROLT;

if (flags & FORK_PPWAIT)

p2->p_flag |= P_PPWAIT;

LIST_INSERT_AFTER(p1, p2, p_pglist);

p2->p_pptr = p1;

if (flags & FORK_NOZOMBIE)

p2->p_flag |= P_NOZOMBIE;

LIST_INSERT_HEAD(&p1->p_children, p2, p_sibling);

LIST_INIT(&p2->p_children);

#ifdef KTRACE

/*

* Copy traceflag and tracefile if enabled.

* If not inherited, these were zeroed above.

*/

if (p1->p_traceflag & KTRFAC_INHERIT) {

p2->p_traceflag = p1->p_traceflag;

if ((p2->p_tracep = p1->p_tracep) != NULL)

VREF(p2->p_tracep);

}

#endif

/*

* set priority of child to be that of parent

* XXX should move p_estcpu into the region of struct proc which gets

* copied.

*/

scheduler_fork_hook(p1, p2);

/*

* Create signal actions for the child process.

*/

if (flags & FORK_SIGHAND)

sigactsshare(p1, p2);

else

p2->p_sigacts = sigactsinit(p1);

/*

* This begins the section where we must prevent the parent

* from being swapped.

*/

PHOLD(p1);

if (flags & FORK_VMNOSTACK) {

/* share as much address space as possible */

(void) uvm_map_inherit(&p1->p_vmspace->vm_map,

VM_MIN_ADDRESS, VM_MAXUSER_ADDRESS - MAXSSIZ,

VM_INHERIT_SHARE);

}

p2->p_addr = (struct user *)uaddr;

/*

* Finish creating the child process. It will return through a

* different path later.

*/

uvm_fork(p1, p2, ((flags & FORK_SHAREVM) ? TRUE : FALSE), stack,

stacksize);

vm = p2->p_vmspace;

if (flags & FORK_FORK) {

forkstat.cntfork++;

forkstat.sizfork += vm->vm_dsize + vm->vm_ssize;

} else if (flags & FORK_VFORK) {

forkstat.cntvfork++;

forkstat.sizvfork += vm->vm_dsize + vm->vm_ssize;

} else if (flags & FORK_RFORK) {

forkstat.cntrfork++;

forkstat.sizrfork += vm->vm_dsize + vm->vm_ssize;

} else {

forkstat.cntkthread++;

forkstat.sizkthread += vm->vm_dsize + vm->vm_ssize;

}

/*

* Make child runnable, set start time, and add to run queue.

*/

s = splstatclock();

p2->p_stats->p_start = time;

p2->p_acflag = AFORK;

p2->p_stat = SRUN;

setrunqueue(p2);

splx(s);

/*

* Now can be swapped.

*/

PRELE(p1);

uvmexp.forks++;

if (flags & FORK_PPWAIT)

uvmexp.forks_ppwait++;

if (flags & FORK_SHAREVM)

uvmexp.forks_sharevm++;

/*

* tell any interested parties about the new process

*/

KNOTE(&p1->p_klist, NOTE_FORK | p2->p_pid);

/*

* Preserve synchronization semantics of vfork. If waiting for

* child to exec or exit, set P_PPWAIT on child, and sleep on our

* proc (in case of exit).

*/

if (flags & FORK_PPWAIT)

while (p2->p_flag & P_PPWAIT)

tsleep(p1, PWAIT, "ppwait", 0);

/*

* Return child pid to parent process,

* marking us as parent via retval[1].

*/

retval[0] = p2->p_pid;

retval[1] = 0;

return (0);

}

总结：以上是我在不同的社区中找的原贴，我觉得比较好滴，就总结滴和大家分享了
网络是个比较好学习的资源，希望大家好好利用

关于FORK（）函数，我有点心得是不懂滴可以在论坛上找，毕竟高手是很多滴

凌风 · #2

哇，这样吧，我虽然不知道上面写什么，大家知道的还是帮助一下LZ

store88 · #3

fork()函数复制进程一个为原来的进程叫父进程还有一个是复制的进程叫子进程
在父进程返回子进程的PID，在子进程返回0

我觉得好像是懂的
不懂楼主想知道什么