足球盘口软件
当前位置: 足球盘口软件 > 前端 >
关于fork函数中的内存复制和共享,进程管理之进程控制三部曲

关于fork函数中的内存复制和共享,fork函数内存共享

  原来刚刚开始做linux下面的多进程编程的时候,对于下面这段代码感到很奇怪,

 1 #include<unistd.h>
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 #include<stdarg.h>
 6 #include<errno.h>
 7 #define LEN 2
 8 void err_exit(char *fmt,...);
 9 int main(int argc,char *argv[])
10 {
11     pid_t pid;
12     int loop; 
13 
14     for(loop=0;loop<LEN;loop++)
15     {
16     if((pid=fork()) < 0)
17         err_exit("[fork:%d]: ",loop);
18     else if(pid == 0)
19     {
20        printf("Child processn"); 
21     }
22     else
23     {
24         sleep(5);
25     }
26     }
27 
28     return 0;
29 }

    为什么这段程序会创建3个子进程,而不是两个,为什么在第20行后面加上一个return 0;就创建的又是两个子进程了?原来一直搞不明白,后来了解了C语言程序的存储空间布局以及在fork之后父子进程是共享正文段(代码段CS)之后才明白这其中的缘由!具体原理是啥,且容我慢慢道来!

 

    首先得明白一个东西就是C程序的存储空间布局,如下图所示:

  图片 1(原图出自《UNIX环境高级编程》7.6节)

    当一个C程序执行之后,它会被加载到内存之中,它在内存中的布局如上图,分为这么几个部分,环境变量和命令行参数、栈、堆、数据段(初始化和未初始化的)、正文段,下面挨个来说明这几段分别代表了什么:

    环境变量和命令行参数:这些指的就是Unix系统上的环境变量(比如$PATH)和传给main函数的参数(argv指针所指向的内容)。

    数据段:这个是指在C程序中定义的全局变量,如果没有初始化,那么就存放在未初始化的数据段中,程序运行时统一由exec赋值为0。否则就存放在初始化的数据段中,程序运行时由exec统一从程序文件中读取。(了解汇编的朋友们想必知道汇编语言中的数据段DS,这和汇编中的数据段其实是一个东西)。

    堆:这一部分主要用来动态分配空间。比如在C语言中用malloc申请的空间就是在这个区域申请的。

    正文段:C语言代码并不是直接执行的,而是被编译成了机器指令才能够在电脑上执行,最终生成的机器指令就是存放在这个区域(汇编中的代码段CS指的就是这片区域)。

    栈:个人感觉这是C程序内存布局最关键的部分了。这个部分主要用来做函数调用。具体而言怎么说呢,程序刚开始栈中只有main这一个函数的内容(即main的栈帧),如果main函数要调用func函数,那么func函数的返回地址(main函数的地址),func函数的参数,func函数中定义的局部变量,还有func函数的返回值等等这些都会被压入栈中,这时栈中就多了func函数的内容(func的栈帧)。然后func函数运行完了之后再来弹栈,把它原来压的内容去掉(即清除掉func栈帧),此时栈中又只剩下了main的栈帧。(这片区域就是汇编中的栈段SS)

    OK,这就是C程序的存储器布局。这里我联想到另外一点,就是全局变量和静态变量是存储在数据段中的,而局部变量是存储在栈中的,栈中数据在函数调用完之后一弹栈就没了,这就是为什么全局变量的生存周期比局部变量的生存周期要长的原因。

 

    了解了C程序在存储器的布局之后,我们再来了解fork的内存复制机制,关于这个,我们只需要了解一句话就够了,“子进程复制父进程的数据空间(数据段)、栈和堆,父、子进程共享正文段。”也就是说,对于程序中的数据,子进程要复制一份,但是对于指令,子进程并不复制而是和父进程共享。具体来看下面这段代码(这是我在上面那段代码上稍微添加了一点东西):

 1 /*  这个程序会创建3个子进程,理解这句话,父子进程复制数据段、栈、堆,共享正文段
 2  *
 3  */
 4 #include<unistd.h>
 5 #include<stdio.h>
 6 #include<string.h>
 7 #include<stdlib.h>
 8 #include<stdarg.h>
 9 #include<errno.h>
10 #define BUFSIZE 512
11 #define LEN 2
12 void err_exit(char *fmt,...);
13 int main(int argc,char *argv[])
14 {
15     pid_t pid;
16     int loop; 
17 
18     for(loop=0;loop<LEN;loop++)
19     {
20     printf("Now is No.%d loop:n",loop);
21 
22     if((pid=fork()) < 0)
23         err_exit("[fork:%d]: ",loop);
24     else if(pid == 0)
25     {
26        printf("[Child process]P:%d C:%dn",getpid(),getppid()); 
27     }
28     else
29     {
30         sleep(5);
31     }
32     }
33 
34     return 0;
35 }

    为什么上面那段代码会创建三个子进程?我们来具体分析一下它的执行过程:

    首先父进程执行循环,通过fork创建一个子进程,然后sleep5秒。

    再来看父进程创建的这个子进程,这里我们记为子进程1.子进程1完全复制了这个父进程的数据部分,但是需要注意的是它的正文段是和父进程共享的。也就是说,子进程1开始执行代码的部分并不是从main的 { 开始执行的,而是主函数执行到哪里了,它就接着执行,具体而言就是它会执行fork后面的代码。所以子进程1首先会打印出它的ID和它的父进程的ID。然后继续第二遍循环,然后这个子进程1再来创建一个子进程,我们记为子进程11,子进程1开始sleep。

    子进程11接着子进程1执行的代码开始执行(即fork后面),它也是打印出它的ID和父进程ID(子进程1),然后此时loop的值再加1就等于2了,所以子进程2直接就返回了。

    那个子进程1sleep完了之后也是loop的值加1之后变成了2,所以子进程1也返回了!

    然后我们再返回去看父进程,它仅仅循环了一次,sleep完之后再来进行第二次循环,这次又创建了一个子进程我们记为子进程2。然后父进程开始sleep,sleep完了之后也结束了。

    那么那个子进程2怎么样了呢?它从fork后开始执行,此时loop等于1,它打印完它的ID和父进程ID之后,就结束循环了,整个子进程2就直接结束了!

    这就是上面那段代码的运行流程,进程间的关系如下图所示:

    图片 2

    上图中那个loop=%d就是当这个进程开始执行的时候loop的值。上面那段代码的运行结果如下图:

    图片 3

    这里这个3498进程就是我们的主进程,3499就是子进程1,3500就是子进程11,3501就是子进程2。

 

    最后,我们再来回答一下我们开始的时候提出的那个问题,为什么在子进程的处理部分“ if(pid == 0) ”最后加一个return 0,就会创建两个子进程了,就是因为子进程1运行到这里直接就结束了,不再进行第二遍循环了,所以就不会再去创建那个子进程11了,所以最后一共就是创建了两个子进程啊!

原来刚刚开始做linux下面的多进程编程的时候,对于下面这段代码感到很奇怪, 1 #inc...

lienhua34
2014-10-05

Linux进程理解与实践(一)基本概念和编程概述(fork,vfork,cow)

进程 and 程序

 

什么是程序? 

 

程序是完成特定任务的一系列指令集合。

 

什么是进程?

 

[1]从用户的角度来看:进程是程序的一次执行过程

 

[2]从操作系统的核心来看:进程是操作系统分配的内存、CPU时间片等资源的基本单位。 

 

[3]进程是资源分配的最小单位

 

[4]每一个进程都有自己独立的地址空间与执行状态。

 

[5]像UNIX这样的多任务操作系统能够让许多程序同时运行,每一个运行着的程序就构成了一个进程

 

 

 

进程数据结构

 

进程由三部分组成:PCB、程序段和数据段。

 

进程控制块PCB:用于描述进程情况及控制进程运行所需的全部信息。

 

代码段:是进程中能被进程调度程序在CPU上执行的程序代码段。

 

数据段:一个进程的数据段,可以是进程对应的程序加工处理的原始数据,也可以是程序执行后产生的中间或最终数据

 

 

 

进程和程序的区别

 

进程是动态的(进程存在的唯一标志:PCB, CPU通过PCB来控制进程),程序是静态的

 

进程的生命周期是相对短暂的,而程序是永久的。

 

一个进程只能对应一个程序,一个程序可以对应多个进程。

 

 

 

进程三态

图片 4

 

 

进程因创建而就绪,因调度而执行;因时间片用完而重新就绪;

 

执行中因I/O请求而阻塞;

 

I/O完成而就绪

 

注意:阻塞以后不能直接执行,必须进入就绪状态。

 

 运行态:进程占用CPU,并在CPU上运行;

 就绪态:进程已经具备运行条件,但是CPU还没有分配过来;

 阻塞态:进程因等待某件事发生而暂时不能运行;

 进程在一生中,都处于上述3中状态之一。

 

知道了进程的三种基本状态,但是在操作系统具体实现中,设计者可以根据实际情况设计不同的状态,于是就有了以下几种状态:

 

Linux内核中的进程状态

图片 5

 

 

运行状态(TASK_RUNNING)

 

可中断睡眠状态(TASK_INTERRUPTIBLE)

 

不可中断睡眠状态(TASK_UNINTERRUPTIBLE)

 

暂停状态(TASK_STOPPED)

 

僵死状态(TASK_ZOMBIE)

 

进程调度

进程调度的任务

 

保存处理机的现场信息

 

按某种算法选取进程

 

把处理器分配给进程

 

进程编程相关术语

进程标志:

 

每个进程都会分配到一个独一无二的数字编号,我们称之为“进程标识”(process identifier),或者就直接叫它PID.

 

是一个正整数,取值范围从2到32768

 

当一个进程被启动时,它会顺序挑选下一个未使用的编号数字做为自己的PID

 

1号进程是特殊进程init

 

0号进程空闲进程

 

关于0,1的解释:

 

进程0:Linux引导中创建的第一个进程,完成加载系统后,演变为进程调度、交换及存储管理进程;

 

进程1:init 进程,由0进程创建,完成系统的初始化. 是系统中所有其它用户进程的祖先进程;

 

Linux内核通过一个被称为进程描述符的task_struct结构体来管理进程,这个结构体包含了一个进程所需的所有信息。

 

进程创建

 

不同的操作系统所提供的进程创建原语的名称和格式不尽相同,但执行创建进程原语后,操作系统所做的工作却大致相同,都包括以下几点:

 

(1)给新创建的进程分配一个内部标识,在内核中建立进程结构。

 

(2)复制父进程的环境

 

(3)为进程分配资源, 包括进程映像所需要的所有元素(程序、数据、用户栈等),

 

(4)复制父进程地址空间的内容到该进程地址空间中。

 

(5)置该进程的状态为就绪,插入就绪队列。

 

 

 

进程撤销

 

进程终止时操作系统做以下工作:

 

(1)关闭软中断:因为进程即将终止而不再处理任何软中断信号;

 

(2)回收资源:释放进程分配的所有资源,如关闭所有已打开文件,释放进程相应的数据结构等;

 

(3)写记帐信息:将进程在运行过程中所产生的记帐数据(其中包括进程运行时的各种统计信息)记录到一个全局记帐文件中;

 

(4)置该进程为僵死状态:向父进程发送子进程死的软中断信号,将终止信息status送到指定的存储单元中;

 

(5)转进程调度:因为此时CPU已经被释放,需要由进程调度进行CPU再分配。

 

 

 

fork系统调用

复制一个进程映象

 

使用fork函数得到的子进程从父进程的继承了整个进程的地址空间,包括:进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设置、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端等。

 

子进程与父进程的区别:

 

1、父进程设置的锁,子进程不继承

 

2、各自的进程ID: 父子进程ID不同

 

3、子进程的未决警告被清除;

 

4、子进程的未决信号集设置为空集;

 

 

 

fork系统调用

 

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片

#include <unistd.h>

pid_t fork(void);

创建一个子进程

 

返回值:

 

如果成功创建一个子进程,对于父进程来说返回子进程ID

 

如果成功创建一个子进程,对于子进程来说返回值为0

 

如果为-1表示创建失败 

 

怎样理解fork函数一次调用,二次返回?

 

问题的本质是:两次返回,是在各自的进程空间中返回的。

 

子进程和父进程各有自己的内存空间 (fork:代码段、数据段、堆栈段、PCB进程控制块的copy)。

 

子进程对的count的改变并不会影响到父进程,因为他们有着自己的数据段。

 

 

//示例: 父子进程中数据的关系(其实基本没关系)
int main(int argc, char *argv[])
{
 signal(SIGCHLD, SIG_IGN);
 int count = 10;
 pid_t pid = fork();
 if (pid == -1)
err_exit("fork error");
 else if (pid == 0)//子进程
 {
++ count;
cout << "In child: pid = " << getpid() << ", ppid = " << getppid() << endl;
cout << "count = " << count << endl;
 }
 else if (pid > 0)//父进程
 {
++ count;
cout << "In parent: pid = " << getpid() << ", child pid = " << pid << endl;
cout << "count = " << count << endl;
 }

 exit(0);
}

 

 

//深入理解: Hello World 为什么会打印8次
int main(int argc, char *argv[])
{
 signal(SIGCHLD, SIG_IGN);
 fork();//每个fork创建一个子进程,然后复制父亲的进程,继续向下执行,所以就像一个二叉树,有4层,所以一共执行了8次 hello wold
 fork();
 fork();
 cout << "Hello World" << endl;

 exit(0);
}

 

//示例: 产生N个子进程
int main(int argc, char *argv[])
{
 signal(SIGCHLD, SIG_IGN);

 int processCount;
 cin >> processCount;
 for (int i = 0; i < processCount; ++i)
 {
pid_t pid = fork();
if (pid < 0)
err_exit("fork error");
else if (pid == 0)
{
cout << "Child ..." << endl;
exit(0);
}
 }

 exit(0);
}

 

COW初窥:

 

在Linux程序中,fork()会产生一个和父进程完全相同的子进程,但子进程在此后多会exec系统调用,出于效率考虑,Linux中引入了“写时复制“技术,也就是只有进程空间的各段的内容要发生变化时,才会将父进程的内容复制一份给子进程。

 

那么子进程的物理空间没有代码,怎么去取指令执行exec系统调用呢?

 

 在fork之后exec之前两个进程用的是相同的物理空间(内存区),子进程的代码段、数据段、堆栈都是指向父进程的物理空间,也就是说,两者的虚拟空间不同,但其对应的物理空间是同一个。当父子进程中有更改相应段的行为发生时,再为子进程相应的段分配物理空间,如果不是因为exec,内核会给子进程的数据段、堆栈段分配相应的物理空间(至此两者有各自的进程空间,互不影响),而代码段继续共享父进程的物理空间(两者的代码完全相同)。而如果是因为exec,由于两者执行的代码不同,子进程的代码段也会分配单独的物理空间。

 

COW详述:

 

现在有一个父进程P1,这是一个主体,那么它是有灵魂也就身体的。现在在其虚拟地址空间(有相应的数据结构表示)上有:正文段,数据段,堆,栈这四个部分,相应的,内核要为这四个部分分配各自的物理块。即:正文段块,数据段块,堆块,栈块。

 

  1. 现在P1用fork()函数为进程创建一个子进程P2,

 

内核:

 

 (1)复制P1的正文段,数据段,堆,栈这四个部分,注意是其内容相同。

 

 (2)为这四个部分分配物理块,P2的:正文段->P1的正文段的物理块,其实就是不为P2分配正文段块,让P2的正文段指向P1的正文段块,数据段->P2自己的数据段块(为其分配对应的块),堆->P2自己的堆块,栈->P2自己的栈块。

 

如下图所示:从左到右大的方向箭头表示复制内容。

图片 6

2.写时复制技术:内核只为新生成的子进程创建虚拟空间结构,它们复制于来自父进程的虚拟空间结构,但是不为这些段分配物理内存,它们共享父进程的物理空间,当父子进程中有更改相应段的行为发生时,再为子进程相应的段分配物理空间。

 

3. vfork():这个做法更加火爆,内核连子进程的虚拟地址空间结构也不创建了,直接共享了父进程的虚拟空间,当然了,这种做法就顺水推舟的共享了父进程的物理空间

图片 7

小结: 进程是一个主体,那么它就有灵魂与身体,系统必须为实现它创建相应的实体, 灵魂实体与物理实体。这两者在系统中都有相应的数据结构表示,物理实体更是体现了它的物理意义。

 

传统的fork()系统调用直接把所有的资源复制给新创建的进程。这种实现过于简单并且效率低下,因为它拷贝的数据也许并不共享,更糟的情况是,如果新进程打算立即执行一个新的映像,那么所有的拷贝都将前功尽弃。Linux的fork()使用写时拷贝(copy-on-write)页实现。写时拷贝是一种可以推迟甚至免除拷贝数据的技术。内核此时并不复制整个进程地址空间,而是让父进程和子进程共享同一个拷贝。只有在需要写入的时候,数据才会被复制,从而使各个进程拥有各自的拷贝。也就是说,资源的复制只有在需要写入的时候才进行,在此之前,只是以只读方式共享。这种技术使地址空间上的页的拷贝被推迟到实际发生写入的时候。在页根本不会被写入的情况下{举例来说:fork()后立即调用exec()}它们就无需复制了。fork()的实际开销就是复制父进程的页表以及给子进程创建惟一的进程描述符。在一般情况下,进程创建后都会马上运行一个可执行的文件,这种优化可以避免拷贝大量根本就不会被使用的数据(地址空间里常常包含数十兆的数据)。由于Unix强调进程快速执行的能力,所以这个优化是很重要的。这里补充一点:Linux COW与exec没有必然联系。

 

 

string str1 = "hello world";

string str2 = str1;

之后执行代码:

 

 

str1[1]='q';

str2[1]='w';

在开始的两个语句后,str1和str2存放数据的地址是一样的,而在修改内容后,str1的地址发生了变化,而str2的地址还是原来的,这就是C++中的COW技术的应用;

) 进程 and 程序 什么是程序? 程序是完成特定任务的一系列指令集合。 什么是进程...

1 进程控制三部曲概述

UNIX 系统提供了 fork、exec、exit 和 wait 等基本的进程控制原语。通过这些进程控制原语,我们即可完成对进程创建、执行和终止等基本操作。进程的控制可以划分为三部曲,

• 第一部:fork 创建新进程。

• 第二部:exec 执行新程序。

• 第三部:exit 和 wait 处理终止和等待终止。

2 第一部:fork 创建新进程

在一个现有的进程中,我们可以通过调用 fork 函数来创建一个新进程,

#include <unistd.h>
pid_t fork(void);
返回值:子进程中返回0,父进程中返回子进程ID,出错则返回-1

由 fork 创建的新进程被称为子进程。fork 函数调用一次,但返回两次。两次返回的唯一区别是:子进程返回值为 0,而父进程的返回值是新子进程的进程 ID。因为 UNIX 系统没有提供一个函数以获取某个进程的所有子进程 ID,所以父进程可以通过 fork 函数的返回值获取其子进程的进程 ID,并进行后续的处理。而在子进程中,可以通过调用 getppid 函数获取其父进程的进程 ID。

fork 函数返回之后,子进程和父进程都各自继续执行 fork 调用之后的指令。子进程是父进程的副本。例如,子进程获得了父进程数据空间、堆和栈的副本。但是,父子进程共享正文段。

例子:

下面程序调用 fork 创建一个新进程,在父子进程中都分别打印当前进程 ID 和父进程 ID。

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
int
main(void)
{
    pid_t pid;
    printf("before forkn");
    if ((pid = fork()) < 0) {
        printf("fork error: %sn", strerror(errno));
        exit(-1);
     } else if (pid == 0) {
        printf("in child process, process ID: %d, parent process ID: %dn", getpid(),  getppid());
    } else {
        printf("in parent process, process ID: %d, child process ID: %dn", getpid(), pid);
        sleep(1);
    }
    exit(0);
}

编译该程序,生成 forkdemo 文件,然后执行该文件,

lienhua34:demo$ gcc -o forkdemo forkdemo.c
lienhua34:demo$ ./forkdemo
before fork
in parent process, process ID: 3499, child process ID: 3500
in child process, process ID: 3500, parent process ID: 3499

第二部:exec 执行新程序

用 fork 函数创建子进程后,子进程往往要调用一种 exec 函数以执行另一个程序。当进程调用一种 exec 函数时,该进程执行的程序完全替换为新程序,而新程序则从其 main 函数开始执行。调用 exec 并没有创建新进程,所以进程 ID 没有改变,exec 只是用一个新的程序替换了当前进程的正文、数据、堆和栈段。

UNIX 提供了 6 种不同的 exec 函数可供使用。我们在这里只说明其中的一种,

#include <unistd.h>
int execv(const char *pathname, char *const argv[]);
返回值:若出错则返回-1,若成功则没有返回值

其中 pathname 是进程要执行的新程序文件的路径,而 argv 参数则是要传递给新程序的参数列表。

例子:

我们有一个 sayhello.c 的程序文件,其代码如下,

#include <stdio.h>
#include <stdlib.h>
int
main(void)
{
    printf("Hello World! process ID: %dn", getpid());
    exit(0);
}

编译 sayhello.c 程序,生成执行文件 sayhello,

lienhua34:demo$ gcc -o sayhello sayhello.c
lienhua34:demo$ pwd
/home/lienhua34/program/c/apue/ch08/demo
lienhua34:demo$ ./sayhello
Hello World! process ID: 3545

在 execdemo.c 程序文件中,我们通过 fork 创建新进程,然后在子进程中调用 execv 函数执行 sayhello 文件,其代码如下,

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
char sayhelloPath[] = "/home/lienhua34/program/c/apue/ch08/demo/sayhello";
int
main(void)
{
    pid_t pid;
    if ((pid = fork()) < 0) {
        printf("fork error: %sn", strerror(errno));
        exit(-1);
    } else if (pid == 0) {
        printf("in child process, process ID: %d, parent process ID: %dn", getpid(), getppid());
        if (execv(sayhelloPath, NULL) < 0) {
            printf("execv error: %sn", strerror(errno));
            exit(-1);
        }
    } else {
        printf("in parent process, process ID: %d, child process ID: %dn", getpid(), pid);
        sleep(2);
    }
    exit(0);
}

编译 execdemo.c 文件,生成并执行 execdemo 文件,

lienhua34:demo$ gcc -o execdemo execdemo.c
lienhua34:demo$ ./execdemo
in parent process, process ID: 3561, child process ID: 3562
in child process, process ID: 3562, parent process ID: 3561
Hello World! process ID: 3562

从上面的运行结果可以看出,子进程(ID:3562)正常执行 sayhello 文件。

4 第三部:exit 和 wait 处理终止和等待终止

exit 函数提供了进程终止的功能,在“进程终止”一文中,我们已经学习了 exit 函数的基本知识。我们这里补充一下关于进程的终止状态。在学习 exit 函数时,我们已经知道 exit 函数的参数作为程序的退出状态(exit status)。在进程终止时,内核会将程序的退出状态作为进程的终止状态(termination status)。在进程异常终止的时候,内核会产生一个指示其异常终止原因的终止状态。无论进程是正常终止还是异常终止,该终止进程的父进程都可以通过 wait 或 waitpid 函数获取其终止状态。

在前面两节中的 forkdemo.c 和 execdemo.c 程序中,fork 调用之后的父进程都调用了 sleep 函数休眠一下。这是因为,在调用 fork 函数之后是父进程先执行还是子进程先执行是不确定的。于是,我们在父进程中调用sleep 休眠一段时间,让子进程先执行结束(注:这样子也不能确保)。

我们可以在父进程中调用 wait 来等待子进程结束,

#include <sys/wait.h>
pid_t wait(int *statloc);
返回值:若成功则返回进程ID,若出错则返回-1

statloc 参数是一个整型指针。如果 statloc 不是一个空指针,则终止进程的终止状态就存储在该指针指向的内存单元中。如果不关心终止状态,则可以将参数设置为 NULL。

进程调用 wait 会导致该调用者阻塞,直到某个子进程终止。如果调用wait 函数时,调用进程没有任何子进程则立即出错返回。

例子:

下面程序在上一节的 execdemo.c 基础上,将 fork 之后父进程的 sleep语句替换成 wait 来等待子进程的结束。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
char sayhelloPath[] = "/home/lienhua34/program/c/apue/ch08/demo/sayhello";
int
main(void)
{
    pid_t pid;
    int waitres;
    if ((pid = fork()) < 0) {
        printf("fork error: %sn", strerror(errno));
        exit(-1);
    } else if (pid == 0) {
        printf("in child process, process ID: %d, parent process ID: %dn", getpid(), getppid());
        if (execv(sayhelloPath, NULL) < 0) {
            printf("execv error: %sn", strerror(errno));
            exit(-1);
       }
    } else {
        printf("in parent process, process ID: %d, child process ID: %dn", getpid(), pid);
        if ((waitres = wait(NULL)) < 0) {
            printf("wait error: %sn", strerror(errno));
            exit(-1);
        } else {
            printf("termination child process: %dn", waitres);
        }
    }
    exit(0);
}

编译该程序,生成并执行 execdemo 文件,

lienhua34:demo$ gcc -o execdemo execdemo.c
lienhua34:demo$ ./execdemo
in parent process, process ID: 3795, child process ID: 3796
in child process, process ID: 3796, parent process ID: 3795
Hello World! process ID: 3796
termination child process: 3796

(done)

上一篇:PIL创建文字图片,python编码总结 下一篇:没有了
返回顶部