Linux下Fork与Exec使用.docx
- 文档编号:5443984
- 上传时间:2022-12-16
- 格式:DOCX
- 页数:11
- 大小:26.64KB
Linux下Fork与Exec使用.docx
《Linux下Fork与Exec使用.docx》由会员分享,可在线阅读,更多相关《Linux下Fork与Exec使用.docx(11页珍藏版)》请在冰豆网上搜索。
Linux下Fork与Exec使用
一、引言
对于没有接触过Unix/Linux操作系统的人来说,fork是最难理解的概念之一:
它执行一次却返回两个值。
fork函数是Unix系统最杰出的成就之一,它是七十年代UNIX早期的开发者经过长期在理论和实践上的艰苦探索后取得的成果,一方面,它使操作系统在进程管理上付出了最小的代价,另一方面,又为程序员提供了一个简洁明了的多进程方法。
与DOS和早期的Windows不同,Unix/Linux系统是真正实现多任务操作的系统,可以说,不使用多进程编程,就不能算是真正的Linux环境下编程。
多线程程序设计的概念早在六十年代就被提出,但直到八十年代中期,Unix系统中才引入多线程机制,如今,由于自身的许多优点,多线程编程已经得到了广泛的应用。
下面,我们将介绍在Linux下编写多进程和多线程程序的一些初步知识。
二、多进程编程
什么是一个进程?
进程这个概念是针对系统而不是针对用户的,对用户来说,他面对的概念是程序。
当用户敲入命令执行一个程序的时候,对系统而言,它将启动一个进程。
但和程序不同的是,在这个进程中,系统可能需要再启动一个或多个进程来完成独立的多个任务。
多进程编程的主要内容包括进程控制和进程间通信,在了解这些之前,我们先要简单知道进程的结构。
2.1Linux下进程的结构
Linux下一个进程在内存里有三部分的数据,就是"代码段"、"堆栈段"和"数据段"。
其实学过汇编语言的人一定知道,一般的CPU都有上述三种段寄存器,以方便操作系统的运行。
这三个部分也是构成一个完整的执行序列的必要的部分。
"代码段",顾名思义,就是存放了程序代码的数据,假如机器中有数个进程运行相同的一个程序,那么它们就可以使用相同的代码段。
"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。
而数据段则存放程序的全局变量,常数以及动态数据分配的数据空间(比如用malloc之类的函数取得的空间)。
这其中有许多细节问题,这里限于篇幅就不多介绍了。
系统如果同时运行数个相同的程序,它们之间就不能使用同一个堆栈段和数据段。
2.2Linux下的进程控制
在传统的Unix环境下,有两个基本的操作用于创建和修改进程:
函数fork()用来创建一个新的进程,该进程几乎是当前进程的一个完全拷贝;函数族exec()用来启动另外的进程以取代当前运行的进程。
Linux的进程控制和传统的Unix进程控制基本一致,只在一些细节的地方有些区别,例如在Linux系统中调用vfork和fork完全相同,而在有些版本的Unix系统中,vfork调用有不同的功能。
由于这些差别几乎不影响我们大多数的编程,在这里我们不予考虑。
2.2.1fork()
fork在英文中是"分叉"的意思。
为什么取这个名字呢?
因为一个进程在运行中,如果使用了fork,就产生了另一个进程,于是进程就"分叉"了,所以这个名字取得很形象。
下面就看看如何具体使用fork,这段程序演示了使用fork的基本框架:
1void main()
2{
3 int i;
4 if ( fork() == 0 )
5 {
6 /* 子进程程序 */
7 for ( i = 1; i <1000; i ++ )
8 printf("This is child process\n");
9 }
10 else
11 {
12 /* 父进程程序*/
13 for ( i = 1; i <1000; i ++ )
14 printf("This is process process\n");
15 }
16}
程序运行后,你就能看到屏幕上交替出现子进程与父进程各打印出的一千条信息了。
如果程序还在运行中,你用ps命令就能看到系统中有两个它在运行了。
那么调用这个fork函数时发生了什么呢?
fork函数启动一个新的进程,前面我们说过,这个进程几乎是当前进程的一个拷贝:
子进程和父进程使用相同的代码段;子进程复制父进程的堆栈段和数据段。
这样,父进程的所有数据都可以留给子进程,但是,子进程一旦开始运行,虽然它继承了父进程的一切数据,但实际上数据却已经分开,相互之间不再有影响了,也就是说,它们之间不再共享任何数据了。
它们再要交互信息时,只有通过进程间通信来实现,这将是我们下面的内容。
既然它们如此相象,系统如何来区分它们呢?
这是由函数的返回值来决定的。
对于父进程,fork函数返回了子程序的进程号,而对于子程序,fork函数则返回零。
在操作系统中,我们用ps函数就可以看到不同的进程号,对父进程而言,它的进程号是由比它更低层的系统调用赋予的,而对于子进程而言,它的进程号即是fork函数对父进程的返回值。
在程序设计中,父进程和子进程都要调用函数fork()下面的代码,而我们就是利用fork()函数对父子进程的不同返回值用if...else...语句来实现让父子进程完成不同的功能,正如我们上面举的例子一样。
我们看到,上面例子执行时两条信息是交互无规则的打印出来的,这是父子进程独立执行的结果,虽然我们的代码似乎和串行的代码没有什么区别。
读者也许会问,如果一个大程序在运行中,它的数据段和堆栈都很大,一次fork就要复制一次,那么fork的系统开销不是很大吗?
其实UNIX自有其解决的办法,大家知道,一般CPU都是以"页"为单位来分配内存空间的,每一个页都是实际物理内存的一个映像,象INTEL的CPU,其一页在通常情况下是4086字节大小,而无论是数据段还是堆栈段都是由许多"页"构成的,fork函数复制这两个段,只是"逻辑"上的,并非"物理"上的,也就是说,实际执行fork时,物理空间上两个进程的数据段和堆栈段都还是共享着的,当有一个进程写了某个数据时,这时两个进程之间的数据才有了区别,系统就将有区别的"页"从物理上也分开。
系统在空间上的开销就可以达到最小。
下面演示一个足以"搞死"Linux的小程序,其源代码非常简单:
1void main()
2{
3 for( ; ; )
4 {
5 fork();
6 }
7}
这个程序什么也不做,就是死循环地fork,其结果是程序不断产生进程,而这些进程又不断产生新的进程,很快,系统的进程就满了,系统就被这么多不断产生的进程"撑死了"。
当然只要系统管理员预先给每个用户设置可运行的最大进程数,这个恶意的程序就完成不了企图了。
2.2.2exec()函数族
下面我们来看看一个进程如何来启动另一个程序的执行。
在Linux中要使用exec函数族。
系统调用execve()对当前进程进行替换,替换者为一个指定的程序,其参数包括文件名(filename)、参数列表(argv)以及环境变量(envp)。
exec函数族当然不止一个,但它们大致相同,在Linux中,它们分别是:
execl,execlp,execle,execv,execve和execvp,下面我只以execlp为例,其它函数究竟与execlp有何区别,请通过manexec命令来了解它们的具体情况。
一个进程一旦调用exec类函数,它本身就"死亡"了,系统把代码段替换成新的程序的代码,废弃原有的数据段和堆栈段,并为新程序分配新的数据段与堆栈段,唯一留下的,就是进程号,也就是说,对系统而言,还是同一个进程,不过已经是另一个程序了。
(不过exec类函数中有的还允许继承环境变量之类的信息。
)
那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话,怎么办呢?
那就是结合fork与exec的使用。
下面一段代码显示如何启动运行其它程序:
1#include
2#include
3#include
4
5char command[256];
6void main()
7{
8 int rtn; /*子进程的返回数值*/
9 while
(1) {
10 /* 从终端读取要执行的命令 */
11 printf( ">" );
12 fgets( command, 256, stdin );
13 command[strlen(command)-1] = 0;
14 if ( fork() == 0 ) {/* 子进程执行此命令 */
15 execlp( command, NULL );
16 /* 如果exec函数返回,表明没有正常执行命令,打印错误信息*/
17 perror( command );
18 exit( errno );
19 }
20 else {/* 父进程, 等待子进程结束,并打印子进程的返回值 */
21 wait ( &rtn );
22 printf( " child process return %d\n", rtn );
23 }
24 }
25}
此程序从终端读入命令并执行之,执行完成后,父进程继续等待从终端读入命令。
熟悉DOS和WINDOWS系统调用的朋友一定知道DOS/WINDOWS也有exec类函数,其使用方法是类似的,但DOS/WINDOWS还有spawn类函数,因为DOS是单任务的系统,它只能将"父进程"驻留在机器内再执行"子进程",这就是spawn类的函数。
WIN32已经是多任务的系统了,但还保留了spawn类函数,WIN32中实现spawn函数的方法同前述UNIX中的方法差不多,开设子进程后父进程等待子进程结束后才继续运行。
UNIX在其一开始就是多任务的系统,所以从核心角度上讲不需要spawn类函数。
在这一节里,我们还要讲讲system()和popen()函数。
system()函数先调用fork(),然后再调用exec()来执行用户的登录shell,通过它来查找可执行文件的命令并分析参数,最后它么使用wait()函数族之一来等待子进程的结束。
函数popen()和函数system()相似,不同的是它调用pipe()函数创建一个管道,通过它来完成程序的标准输入和标准输出。
这两个函数是为那些不太勤快的程序员设计的,在效率和安全方面都有相当的缺陷,在可能的情况下,应该尽量避免。
2.3Linux下的进程间通信
详细的讲述进程间通信在这里绝对是不可能的事情,而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步,所以在这一节的开头首先向大家推荐著名作者RichardStevens的著名作品:
《AdvancedProgrammingintheUNIXEnvironment》,它的中文译本《UNIX环境高级编程》已有机械工业出版社出版,原文精彩,译文同样地道,如果你的确对在Linux下编程有浓厚的兴趣,那么赶紧将这本书摆到你的书桌上或计算机旁边来。
说这么多实在是难抑心中的景仰之情,言归正传,在这一节里,我们将介绍进程间通信最最初步和最最简单的一些知识和概念。
首先,进程间通信至少可以通过传送打开文件来实现,不同的进程通过一个或多个文件来传递信息,事实上,在很多应用系统里,都使用了这种方法。
但一般说来,进程间通信(IPC:
InterProcessCommunication)不包括这种似乎比较低级的通信方法。
Unix系统中实现进程间通信的方法很多,而且不幸的是,极少方法能在所有的Unix系统中进行移植(唯一一种是半双工的管道,这也是最原始的一种通信方式)。
而Linux作为一种新兴的操作系统,几乎支持所有的Unix下常用的进程间通信方法:
管道、消息队列、共享内存、信号量、套接口等等。
下面我们将逐一介绍。
2.3.1管道
管道是进程间通信中最古老的方式,它包括无名管道和有名管道两种,前者用于父进程和子进程间的通信,后者用于运行于同一台机器上的任意两个进程间的通信。
无名管道由pipe()函数创建:
#include
intpipe(intfiledis[2]);
参数filedis返回两个文件描述符:
filedes[0]为读而打开,filedes[1]为写而打开。
filedes[1]的输出是filedes[0]的输入。
下面的例子示范了如何在父进程和子进程间实现通信。
1 #define INPUT 0
2 #define OUTPUT 1
3
4 void main() {
5 int file_descriptors[2];
6 /*定义子进程号 */
7 pid_t pid;
8 char buf[256];
9 int returned_count;
10 /*创建无名管道*/
11 pipe(file_descriptors);
12 /*创建子进程*/
13 if((pid = fork()) == -1) {
14 printf("Error in fork\n");
15 exit
(1);
16 }
17 /*执行子进程*/
18 if(pid == 0) {
19 printf("in the spawned (child) process...\n");
20 /*子进程向父进程写数据,关闭管道的读端*/
21 close(file_descriptors[INPUT]);
22 write(file_descriptors[OUTPUT], "test data", strlen("test data"));
23 exit(0);
24 } else {
25 /*执行父进程*/
26 printf("in the spawning (parent) process...\n");
27 /*父进程从管道读取子进程写的数据,关闭管道的写端*/
28 close(file_descriptors[OUTPUT]);
29 returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
30 printf("%d bytes of data received from spawned process:
%s\n",
31 returned_count, buf);
32 }
33 }
在Linux系统下,有名管道可由两种方式创建:
命令行方式mknod系统调用和函数mkfifo。
下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道:
方式一:
mkfifo("myfifo","rw");
方式二:
mknodmyfifop
生成了有名管道后,就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。
下面即是一个简单的例子,假设我们已经创建了一个名为myfifo的有名管道。
1/* 进程一:
读有名管道*/
2#include
3#include
4void main() {
5 FILE * in_file;
6 int count = 1;
7 char buf[80];
8 in_file = fopen("mypipe", "r");
9 if (in_file == NULL) {
10 printf("Error in fdopen.\n");
11 exit
(1);
12 }
13 while ((count = fread(buf, 1, 80, in_file)) > 0)
14 printf("received from pipe:
%s\n", buf);
15 fclose(in_file);
16}
17/* 进程二:
写有名管道*/
18#include
19#include
20void main() {
21 FILE * out_file;
22 int count = 1;
23 char buf[80];
24 out_file = fopen("mypipe", "w");
25 if (out_file == NULL) {
26 printf("Error opening pipe.");
27 exit
(1);
28 }
29 sprintf(buf,"this is test data for the named pipe example\n");
30 fwrite(buf, 1, 80, out_file);
31 fclose(out_file);
32}
33
2.3.2消息队列
消息队列用于运行于同一台机器上的进程间通信,它和管道很相似,事实上,它是一种正逐渐被淘汰的通信方式,我们可以用流管道或者套接口的方式来取代它,所以,我们对此方式也不再解释,也建议读者忽略这种方式。
2.3.3共享内存
共享内存是运行在同一台机器上的进程间通信最快的方式,因为数据不需要在不同的进程间复制。
通常由一个进程创建一块共享内存区,其余进程对这块内存区进行读写。
得到共享内存有两种方式:
映射/dev/mem设备和内存映像文件。
前一种方式不给系统带来额外的开销,但在现实中并不常用,因为它控制存取的将是实际的物理内存,在Linux系统下,这只有通过限制Linux系统存取的内存才可以做到,这当然不太实际。
常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。
首先要用的函数是shmget,它获得一个共享存储标识符。
#include
#include
#include
intshmget(key_tkey,intsize,intflag);
这个函数有点类似大家熟悉的malloc函数,系统按照请求分配size大小的内存用作共享内存。
Linux系统内核中每个IPC结构都有的一个非负整数的标识符,这样对一个消息队列发送消息时只要引用标识符就可以了。
这个标识符是内核由IPC结构的关键字得到的,这个关键字,就是上面第一个函数的key。
数据类型key_t是在头文件sys/types.h中定义的,它是一个长整形的数据。
在我们后面的章节中,还会碰到这个关键字。
当共享内存创建后,其余进程可以调用shmat()将其连接到自身的地址空间中。
void*shmat(intshmid,void*addr,intflag);
shmid为shmget函数返回的共享存储标识符,addr和flag参数决定了以什么方式来确定连接的地址,函数的返回值即是该进程数据段所连接的实际地址,进程可以对此进程进行读写操作。
使用共享存储来实现进程间通信的注意点是对数据存取的同步,必须确保当一个进程去读取数据时,它所想要的数据已经写好了。
通常,信号量被要来实现对共享存储数据存取的同步,另外,可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。
2.3.4信号量
信号量又称为信号灯,它是用来协调不同进程间的数据对象的,而最主要的应用是前一节的共享内存方式的进程间通信。
本质上,信号量是一个计数器,它用来记录对某个资源(如共享内存)的存取状况。
一般说来,为了获得共享资源,进程需要执行下列操作:
(1)测试控制该资源的信号量。
(2)若此信号量的值为正,则允许进行使用该资源。
进程将进号量减1。
(3)若此信号量为0,则该资源目前不可用,进程进入睡眠状态,直至信号量值大于0,进程被唤醒,转入步骤
(1)。
(4)当进程不再使用一个信号量控制的资源时,信号量值加1。
如果此时有进程正在睡眠等待此信号量,则唤醒此进程。
维护信号量状态的是Linux内核操作系统而不是用户进程。
我们可以从头文件/usr/src/linux/include /linux /sem.h中看到内核用来维护信号量状态的各个结构的定义。
信号量是一个数据集合,用户可以单独使用这一集合的每个元素。
要调用的第一个函数是semget,用以获得一个信号量ID。
#include
#include
#include
intsemget(key_tkey,intnsems,intflag);
key是前面讲过的IPC结构的关键字,它将来决定是创建新的信号量集合,还是引用一个现有的信号量集合。
nsems是该集合中的信号量数。
如果是创建新集合(一般在服务器中),则必须指定nsems;如果是引用一个现有的信号量集合(一般在客户机中)则将nsems指定为0。
semctl函数用来对信号量进行操作。
intsemctl(intsemid,intsemnum,intcmd,unionsemunarg);
不同的操作是通过cmd参数来实现的,在头文件sem.h中定义了7种不同的操作,实际编程时可以参照使用。
semop函数自动执行信号量集合上的操作数组。
intsemop(intsemid,structsembufsemoparray[],size_tnops);
semoparray是一个指针,它指向一个信号量操作数组。
nops规定该数组中操作的数量。
下面,我们看一个具体的例子,它创建一个特定的IPC结构的关键字和一个信号量,建立此信号量的索引,修改索引指向的信号量的值,最后我们清除信号量。
在下面的代码中,函数ftok生成我们上文所说的唯一的IPC关键字。
1#include
2#include
3#include
4#include
5void main() {
6 key_t unique_key; /* 定义一个IPC关键字*/
7 int id;
8 struct sembuf lock_it;
9 union semun options;
10 int i;
11
12 unique_key = ftok(".", 'a'); /* 生成关键字,字符'a'是一个随机种子*/
13 /* 创建一个新的信号量集合*/
14 id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);
15 printf("se
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Linux Fork Exec 使用