当前时区为 UTC + 8 小时



发表新帖 回复这个主题  [ 3 篇帖子 ] 
作者 内容
1 楼 
 文章标题 : 关于fork()函数
帖子发表于 : 2007-12-01 16:36 
头像

注册: 2007-11-15 9:45
帖子: 13
地址: IT
送出感谢: 0 次
接收感谢: 0 次
#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 楼 
 文章标题 :
帖子发表于 : 2007-12-01 18:12 

注册: 2007-11-17 23:34
帖子: 28
送出感谢: 0 次
接收感谢: 0 次
哇,这样吧,我虽然不知道上面写什么,大家知道的还是帮助一下LZ


页首
 用户资料  
 
3 楼 
 文章标题 :
帖子发表于 : 2007-12-01 20:13 

注册: 2005-10-15 0:30
帖子: 109
地址: China
送出感谢: 0 次
接收感谢: 0 次
fork()函数 复制进程 一个为原来的进程叫父进程 还有一个是复制的进程叫子进程
在父进程返回子进程的PID,在子进程返回0

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


页首
 用户资料  
 
显示帖子 :  排序  
发表新帖 回复这个主题  [ 3 篇帖子 ] 

当前时区为 UTC + 8 小时


在线用户

正在浏览此版面的用户:没有注册用户 和 4 位游客


不能 在这个版面发表主题
不能 在这个版面回复主题
不能 在这个版面编辑帖子
不能 在这个版面删除帖子
不能 在这个版面提交附件

前往 :  
本站点为公益性站点,用于推广开源自由软件,由 DiaHosting VPSBudgetVM VPS 提供服务。
我们认为:软件应可免费取得,软件工具在各种语言环境下皆可使用,且不会有任何功能上的差异;
人们应有定制和修改软件的自由,且方式不受限制,只要他们自认为合适。

Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
简体中文语系由 王笑宇 翻译