Linux多进程编程讲解

转载 2012年03月29日 17:13:18

1 Linux下进程的结构

   Linux下一个进程在内存里有三部分的数据,就是"代码段""堆栈段""数据段"。一般的CPU都有上述三种段寄存器,以方便操作系统的运行。这三个部分也是构成一个完整的执行序列的必要的部分。

   "代码段",顾名思义,就是存放了程序代码的数据,假如机器中有数个进程运行相同的一个程序,那么它们就可以使用相同的代码段。"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量,常数以及动态数据分配的数据空间(比如用malloc之类的函数取得的空间)。系统如果同时运行数个相同的程序,它们之间就不能使用同一个堆栈段和数据段。

2 Linux进程控制

   在传统的Unix环境下,有两个基本的操作用于创建和修改进程:函数fork( )用来创建一个新的进程,该进程几乎是当前进程的一个完全拷贝;函数族exec( )用来启动另外的进程以取代当前运行的进程。

2.1 使用fork()

        使用fork()的简单例子:

void main(){

int i;

if ( fork() == 0 ) {

/* 子进程程序 */

for ( i = 1; i <1000; i ++ ) printf("This is child process"n");

}

else {

/* 父进程程序*/

for ( i = 1; i <1000; i ++ ) printf("This is process process"n");

}

}

   程序运行后,能看到屏幕上交替出现子进程与父进程各打印出的信息了。如果程序还在运行中,用ps命令就能看到系统中有两个它在运行了。

   fork函数启动一个新的进程,是当前进程的一个拷贝:子进程和父进程使用相同的代码段;子进程复制父进程的堆栈段和数据段。这样,父进程的所有数据都可以留给子进程,但是,子进程一旦开始运行,虽然它继承了父进程的一切数据,但实际上数据却已经分开,相互之间不再有影响了,也就是说,它们之间不再共享任何数据了。它们再要交互信息时,只有通过进程间通信来实现。

     对于父进程,fork函数返回子程序的进程号,而对于子程序,fork函数则返回零。在操作系统中,我们用ps函数就可以看到不同的进程号,对父进程而言,它的进程号是由比它更低层的系统调用赋予的,而对于子进程而言,它的进程号即是fork函数对父进程的返回值。在程序设计中,父进程和子进程都要调用函数fork()下面的代码,而我们就是利用fork()函数对父子进程的不同返回值用if...else...语句来实现让父子进程完成不同的功能,正如我们上面举的例子一样。我们看到,上面例子执行时两条信息是交互无规则的打印出来的,这是父子进程独立执行的结果,虽然我们的代码似乎和串行的代码没有什么区别。

 

   一般CPU都是以""为单位来分配内存空间的,每一个页都是实际物理内存的一个映像,象INTELCPU,其一页在通常情况下是4086字节大小,而无论是数据段还是堆栈段都是由许多""构成的,fork函数复制这两个段,只是"逻辑"上的,并非"物理"上的,也就是说,实际执行fork时,物理空间上两个进程的数据段和堆栈段都还是共享着的,当有一个进程写了某个数据时,这时两个进程之间的数据才有了区别,系统就将有区别的""从物理上也分开。系统在空间上的开销就可以达到最小。

 

2.2 exec( )函数族

   Linux中一个进程启动另一个程序的执行使用exec函数族。一个进程一旦调用exec类函数,它本身就"死亡"了,系统把代码段替换成新的程序的代码,废弃原有的数据段和堆栈段,并为新程序分配新的数据段与堆栈段,唯一留下的,就是进程号,也就是说,对系统而言,还是同一个进程,不过已经是另一个程序了。(不过exec类函数中有的还允许继承环境变量之类的信息。)那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话,可以结合forkexec的使用。下面一段代码显示如何启动运行其它程序:

 

char command[256];

void main()

{

int rtn; /*子进程的返回数值*/

while(1) {

/* 从终端读取要执行的命令 */

printf( ">" );

fgets( command, 256, stdin );

command[strlen(command)-1] = 0;

if ( fork() == 0 ) {

/* 子进程执行此命令 */

execlp( command, command );

/* 如果exec函数返回,表明没有正常执行命令,打印错误信息*/

perror( command );

exit( errorno );

}

else {

/* 父进程, 等待子进程结束,并打印子进程的返回值 */

wait ( &rtn );

printf( " child process return %d"n",. rtn );

}

}

}

   此程序从终端读入命令并执行之,执行完成后,父进程继续等待从终端读入命令。

3 Linux进程间通信

   首先,进程间通信至少可以通过传送打开文件来实现,不同的进程通过一个或多个文件来传递信息,事实上,在很多应用系统里,都使用了这种方法。但一般说来,进程间通信(IPCInterProcess Communication)不包括这种似乎比较低级的通信方法。Linux作为一种新兴的操作系统,几乎支持所有的Unix下常用的进程间通信方法:管道、消息队列、共享内存、信号量、套接口等等。

 

3.1 管道

   管道是进程间通信中最古老的方式,它包括无名管道和有名管道两种,前者用于父进程和子进程间的通信,后者用于运行于同一台机器上的任意两个进程间的通信。

   无名管道由pipe()函数创建,下面的例子示范了如何在父进程和子进程间实现通信:

#define INPUT 0

#define OUTPUT 1

void main() {

int file_descriptors[2];

pid_t pid;

char buf[256];

int returned_count;

pipe(file_descriptors);  /*创建无名管道*/

if((pid = fork()) == -1) { /*创建子进程*/

printf("Error in fork"n");

exit(1);

}

if(pid == 0) {

printf("in the spawned (child) process..."n");

/*子进程向父进程写数据,关闭管道的读端*/

close(file_descriptors[INPUT]);

write(file_descriptors[OUTPUT], "test data", strlen("test data"));

exit(0);

} else {

printf("in the spawning (parent) process..."n");

/*父进程从管道读取子进程写的数据,关闭管道的写端*/

close(file_descriptors[OUTPUT]);

returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));

printf("%d bytes of data received from spawned process: %s"n",

returned_count, buf);

}

}

   Linux系统下,有名管道可由两种方式创建:命令行方式mknod系统调用和函数mkfifo。下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道:

     方式一:mkfifo("myfifo","rw");

     方式二:mknod myfifo p

   生成了有名管道后,就可以使用一般的文件I/O函数如openclosereadwrite等来对它进行操作。下面即是一个简单的例子,假设我们已经创建了一个名为myfifo的有名管道。

/* 进程一:读有名管道*/

#include <stdio.h>

#include <unistd.h>

void main() {

FILE * in_file;

int count = 1;

char buf[80];

in_file = fopen("mypipe", "r");

if (in_file == NULL) {

printf("Error in fdopen."n");

exit(1);

}

while ((count = fread(buf, 1, 80, in_file)) > 0)

printf("received from pipe: %s"n", buf);

fclose(in_file);

}

 

/* 进程二:写有名管道*/

#include <stdio.h>

#include <unistd.h>

void main() {

FILE * out_file;

int count = 1;

char buf[80];

out_file = fopen("mypipe", "w");

if (out_file == NULL) {

printf("Error opening pipe.");

exit(1);

}

sprintf(buf,"this is test data for the named pipe example"n");

fwrite(buf, 1, 80, out_file);

fclose(out_file);

}

 

3.2 消息队列

   消息队列用于运行于同一台机器上的进程间通信,它和管道很相似,事实上,它是一种正逐渐被淘汰的通信方式,我们可以用流管道或者套接口的方式来取代它,所以,我们对此方式也不再解释,也建议读者忽略这种方式。

3.3 共享内存

   共享内存是运行在同一台机器上的进程间通信最快的方式,因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区,其余进程对这块内存区进行读写。得到共享内存有两种方式:映射/dev/mem设备和内存映像文件。

前一种方式不给系统带来额外的开销,但在现实中并不常用,因为它控制存取的将是实际的物理内存,在Linux系统下,这只有通过限制Linux系统存取的内存才可以做到,这当然不太实际。常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。

   首先要用的函数是shmget,它获得一个共享存储标识符。

     #include <sys/types.h>

     #include <sys/ipc.h>

     #include <sys/shm.h>

    int shmget(key_t key, int size, int flag);

   这个函数有点类似大家熟悉的malloc函数,系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符,这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的,这个关键字,就是上面第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的,它是一个长整形的数据。在我们后面的章节中,还会碰到这个关键字。

  共享内存创建后,其余进程可以调用shmat()将其连接到自身的地址空间中。

   void *shmat(int shmid, void *addr, int flag);

   shmidshmget函数返回的共享存储标识符,addrflag参数决定了以什么方式来确定连接的地址,函数的返回值即是该进程数据段所连接的实际地址,进程可以对此进程进行读写操作。

   使用共享存储来实现进程间通信的注意点是对数据存取的同步,必须确保当一个进程去读取数据时,它所想要的数据已经写好了。通常,信号量被要来实现对共享存储数据存取的同步,另外,可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCKSHM_UNLOCK等来实现。

3.4 信号量

   信号量又称为信号灯,它是用来协调不同进程间的数据对象的,而最主要的应用是前一节的共享内存方式的进程间通信。本质上,信号量是一个计数器,它用来记录对某个资源(如共享内存)的存取状况。一般说来,为了获得共享资源,进程需要执行下列操作:

   1 测试控制该资源的信号量。

   2 若此信号量的值为正,则允许进行使用该资源。进程将进号量减1

   3 若此信号量为0,则该资源目前不可用,进程进入睡眠状态,直至信号量值大于0,进程被唤醒,转入步骤(1)。

   4 当进程不再使用一个信号量控制的资源时,信号量值加1。如果此时有进程正在睡眠等待此信号量,则唤醒此进程。

   维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文件/usr/src/linux/include /linux/sem.h中看到内核用来维护信号量状态的各个结构的定义。信号量是一个数据集合,用户可以单独使用这一集合的每个元素。要调用的第一个函数是semget,用以获得一个信号量ID

   #include <sys/types.h>

   #include <sys/ipc.h>

   #include <sys/sem.h>

   int semget(key_t key, int nsems, int flag);

   key是前面讲过的IPC结构的关键字,它将来决定是创建新的信号量集合,还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合(一般在服务器中),则必须指定nsems;如果是引用一个现有的信号量集合(一般在客户机中)则将nsems指定为0

   semctl函数用来对信号量进行操作。

   int semctl(int semid, int semnum, int cmd, union semun arg);

   不同的操作是通过cmd参数来实现的,在头文件sem.h中定义了7种不同的操作,实际编程时可以参照使用。

   semop函数自动执行信号量集合上的操作数组。

   int semop(int semid, struct sembuf semoparray[], size_t nops);

   semoparray是一个指针,它指向一个信号量操作数组。nops规定该数组中操作的数量。

   下面,我们看一个具体的例子,它创建一个特定的IPC结构的关键字和一个信号量,建立此信号量的索引,修改索引指向的信号量的值,最后我们清除信号量。在下面的代码中,函数ftok生成我们上文所说的唯一的IPC关键字。

 

#include <stdio.h>

#include <sys/types.h>

#include <sys/sem.h>

#include <sys/ipc.h>

void main() {

key_t unique_key; /* 定义一个IPC关键字*/

int id;

struct sembuf lock_it;

union semun options;

int i;

unique_key = ftok(".", 'a'); /* 生成关键字,字符'a'是一个随机种子*/

/* 创建一个新的信号量集合*/

id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);

printf("semaphore id=%d"n", id);

options.val = 1; /*设置变量值*/

semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/

/*打印出信号量的值*/

i = semctl(id, 0, GETVAL, 0);

printf("value of semaphore at index 0 is %d"n", i);

/*下面重新设置信号量*/

lock_it.sem_num = 0; /*设置哪个信号量*/

lock_it.sem_op = -1; /*定义操作*/

lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/

if (semop(id, &lock_it, 1) == -1) {

printf("can not lock semaphore."n");

exit(1);

}

i = semctl(id, 0, GETVAL, 0);

printf("value of semaphore at index 0 is %d"n", i);

/*清除信号量*/

semctl(id, 0, IPC_RMID, 0);

}

3.5 套接口

   套接口(socket)编程是实现Linux系统和其他大多数操作系统中进程间通信的主要方式之一。我们熟知的WWW服务、FTP服务等都是基于套接口编程来实现的。除了在异地的计算机进程间以外,套接口同样适用于本地同一台计算机内部的进程间通信。

具体略。

4 Linux的进程和Win32的进程/线程比较

   熟悉WIN32编程的人一定知道,WIN32的进程管理方式与Linux上有着很大区别,在UNIX里,只有进程的概念,但在WIN32里却还有一个"线程"的概念,那么LinuxWIN32在这里究竟有着什么区别呢?

   WIN32里的进程/线程是继承自OS/2的。在WIN32里,"进程"是指一个程序,而"线程"是一个"进程"里的一个执行"线索"。从核心上讲,WIN32的多进程与Linux并无多大的区别,在WIN32里的线程才相当于Linux的进程,是一个实际正在执行的代码。但是,WIN32里同一个进程里各个线程之间是共享数据段的。这才是与Linux的进程最大的不同。

   下面这段程序显示了WIN32下一个进程如何启动一个线程。

 

int g;

DWORD WINAPI ChildProcess( LPVOID lpParameter ){

int i;

for ( i = 1; i <1000; i ++) {

g ++;

printf( "This is Child Thread: %d"n", g );

}

ExitThread( 0 );

};

 

void main()

{

int threadID;

int i;

g = 0;

CreateThread( NULL, 0, ChildProcess, NULL, 0, &threadID );

for ( i = 1; i <1000; i ++) {

g ++;

printf( "This is Parent Thread: %d"n", g );

}

}

    WIN32下,使用CreateThread函数创建线程,与Linux下创建进程不同,WIN32线程不是从创建处开始运行的,而是由CreateThread指定一个函数,线程就从那个函数处开始运行。此程序同前面的UNIX程序一样,由两个线程各打印1000条信息。threadID是子线程的线程号,另外,全局变量g是子线程与父线程共享的,这就是与Linux最大的不同之处。大家可以看出,WIN32的进程/线程要比Linux复杂,在Linux要实现类似WIN32的线程并不难,只要fork以后,让子进程调用ThreadProc函数,并且为全局变量开设共享数据区就行了,但在WIN32下就无法实现类似fork的功能了。所以现在WIN32下的C语言编译器所提供的库函数虽然已经能兼容大多数Linux/UNIX的库函数,但却仍无法实现fork

   对于多任务系统,共享数据区是必要的,但也是一个容易引起混乱的问题,在WIN32下,一个程序员很容易忘记线程之间的数据是共享的这一情况,一个线程修改过一个变量后,另一个线程却又修改了它,结果引起程序出问题。但在Linux下,由于变量本来并不共享,而由程序员来显式地指定要共享的数据,使程序变得更清晰与安全。至于WIN32"进程"概念,其含义则是"应用程序",也就是相当于UNIX下的exec了。


原文地址:http://www.cnblogs.com/Myhsg/archive/2009/07/26/1531502.html

相关文章推荐

Linux下的多进程编程初步

  • 2007年12月10日 18:23
  • 140KB
  • 下载

Linux下C语言中的多进程编程资料

  • 2009年04月26日 18:15
  • 6.81MB
  • 下载

【linux】多进程、多线程编程

linux下进程   (一) 理解Linux下进程的结构     Linux下一个进程在内存里有三部份的数据,就是“数据段”,“堆栈段”和“代码段”,其实学过汇编语言的人一定知道,一般的...

linux下多进程、多线程编程

  • 2009年07月08日 14:55
  • 212KB
  • 下载

linux下多进程和多线程编程之二(同步)

多进程,多线程的同步  多进程和多线程的同步,我们重点讲解下多线程下的同步,这个是编程中最常用的。 多线程同步,总结以下几种机制方式 第一:互斥锁 互斥锁的原理是利用互斥性,保证程序在某一刻只有一个线...

Linux下的多进程编程初步(转载)

最近在学习linux环境高级编程,多进程编程算是编程中的最重要的一个部分了,本文让我学习和明白了很多,所以转载过来。让更多想多线程编程的人学习。只有顶到首页才能让更多的人学习。 文章摘要:  ...
  • xasylt
  • xasylt
  • 2015年03月14日 17:32
  • 150

linux 应用编程——多进程

实例内容:一个父进程创建两个子进程,其中一个子进程运行“ls -l”的指令,另一个子进程在等待5s之后异常退                      出,父进程先用阻塞方式等待第一个子进程的结束,然...

Linux下的多进程编程(理解)

(一) 理解Linux下进程的结构   Linux下一个进程在内存里有三部份的数据,就是“数据段”,“堆栈段”和“代码段”,其实学过汇编 语言的人一定知道,一般的CPU象I386,都有上述三种段寄...

linux高性能服务器编程之多进程

转载自 http://www.cnblogs.com/Anker/p/3271773.html 就喜欢这样有demo代码,自己亲身敲代码来验证概念的感觉,哈哈 1. 创建进程fork 什么是僵尸...

Linux编程——多进程程序设计

本文学习Linux环境下的多进程编程,在我之前的文章里已经讲过进程与线程。本文,再简单讲一下进程的概念,方便接下来的学习。     进程定义:进程是一个具有一定独立功能的程序的一次运行活动。     ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Linux多进程编程讲解
举报原因:
原因补充:

(最多只允许输入30个字)