Linux下多进程编程

1 引言 
　　 对于没有接触过Unix/Linux操作系统的人来说，fork是最难理解的概念之一：它执行一次却返回两个值。fork函数是Unix系统最杰出的成就之一，它是七十年代UNIX早期的开发者经过长期在理论和实践上的艰苦探索后取得的成果，一方面，它使操作系统在进程管理上付出了最小的代价，另一方面，又为程序员提供了一个简洁明了的多进程方法。与DOS和早期的Windows不同，Unix/Linux系统是真正实现多任务操作的系统，可以说，不使用多进程编程，就不能算是真正的Linux环境下编程。 
　　 多线程程序设计的概念早在六十年代就被提出，但直到八十年代中期，Unix系统中才引入多线程机制，如今，由于自身的许多优点，多线程编程已经得到了广泛的应用。 
　　 下面，我们将介绍在Linux下编写多进程和多线程程序的一些初步知识。 
2 多进程编程 
　　 什么是一个进程？进程这个概念是针对系统而不是针对用户的，对用户来说，他面对的概念是程序。当用户敲入命令执行一个程序的时候，对系统而言，它将启动一个进程。但和程序不同的是，在这个进程中，系统可能需要再启动一个或多个进程来完成独立的多个任务。多进程编程的主要内容包括进程控制和进程间通信，在了解这些之前，我们先要简单知道进程的结构。 
　 2.1 Linux下进程的结构 
　　 Linux下一个进程在内存里有三部分的数据，就是"代码段"、"堆栈段"和"数据段"。其实学过汇编语言的人一定知道，一般的CPU都有上述三种段寄存器，以方便操作系统的运行。这三个部分也是构成一个完整的执行序列的必要的部分。 
　　 "代码段"，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc之类的函数取得的空间）。这其中有许多细节问题，这里限于篇幅就不多介绍了。系统如果同时运行数个相同的程序，它们之间就不能使用同一个堆栈段和数据段。 
　 2.2 Linux下的进程控制 
　　 在传统的Unix环境下，有两个基本的操作用于创建和修改进程：函数fork( )用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；函数族exec( )用来启动另外的进程以取代当前运行的进程。Linux的进程控制和传统的Unix进程控制基本一致，只在一些细节的地方有些区别，例如在Linux系统中调用vfork和fork完全相同，而在有些版本的Unix系统中，vfork调用有不同的功能。由于这些差别几乎不影响我们大多数的编程，在这里我们不予考虑。 
　　 2.2.1 fork( ) 
　　 fork在英文中是"分叉"的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就"分叉"了，所以这个名字取得很形象。下面就看看如何具体使用fork，这段程序演示了使用fork的基本框架： 
void main(){ 
int i; 
if ( fork() == 0 ) { 
/* 子进程程序 */ 
for ( i = 1; i " ); 
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 ); 
} 
} 
} 
　　 此程序从终端读入命令并执行之，执行完成后，父进程继续等待从终端读入命令。熟悉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.3 Linux下的进程间通信 
　　 详细的讲述进程间通信在这里绝对是不可能的事情，而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步，所以在这一节的开头首先向大家推荐著名作者Richard Stevens的著名作品：《Advanced Programming in the UNIX Environment》，它的中文译本《UNIX环境高级编程》已有机械工业出版社出版，原文精彩，译文同样地道，如果你的确对在Linux下编程有浓厚的兴趣，那么赶紧将这本书摆到你的书桌上或计算机旁边来。说这么多实在是难抑心中的景仰之情，言归正传，在这一节里，我们将介绍进程间通信最最初步和最最简单的一些知识和概念。 
　　 首先，进程间通信至少可以通过传送打开文件来实现，不同的进程通过一个或多个文件来传递信息，事实上，在很多应用系统里，都使用了这种方法。但一般说来，进程间通信（IPC：InterProcess Communication）不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多，而且不幸的是，极少方法能在所有的Unix系统中进行移植（唯一一种是半双工的管道，这也是最原始的一种通信方式）。而Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信方法：管道、消息队列、共享内存、信号量、套接口等等。下面我们将逐一介绍。 
　　 2.3.1 管道 
　　 管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。 
　　 无名管道由pipe（）函数创建： 
　　 #include  
　　 int pipe(int filedis[2])； 
　　 参数filedis返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。下面的例子示范了如何在父进程和子进程间实现通信。 
#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函数如open、close、read、write等来对它进行操作。下面即是一个简单的例子，假设我们已经创建了一个名为myfifo的有名管道。 
　 /* 进程一：读有名管道*/ 
#include  
#include  
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  
#include  
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); 
} 
　　 2.3.2 消息队列 
　　 消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它，所以，我们对此方式也不再解释，也建议读者忽略这种方式。 
　　 2.3.3 共享内存 
　　 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过限制Linux系统存取的内存才可以做到，这当然不太实际。常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。 
　　 首先要用的函数是shmget，它获得一个共享存储标识符。 
　　　　 #include  
　　　　 #include  
　　　　 #include  
　　　　　 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); 
　　 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  
　　 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  
#include  
#include  
#include  
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); 
} 
　　 2.3.5 套接口 
　　 套接口（socket）编程是实现Linux系统和其他大多数操作系统中进程间通信的主要方式之一。我们熟知的WWW服务、FTP服务、TELNET服务等都是基于套接口编程来实现的。除了在异地的计算机进程间以外，套接口同样适用于本地同一台计算机内部的进程间通信。关于套接口的经典教材同样是Richard Stevens编著的《Unix网络编程：联网的API和套接字》，清华大学出版社出版了该书的影印版。它同样是Linux程序员的必备书籍之一。 
　　 关于这一部分的内容，可以参照本文作者的另一篇文章《设计自己的网络蚂蚁》，那里由常用的几个套接口函数的介绍和示例程序。这一部分或许是Linux进程间通信编程中最须关注和最吸引人的一部分，毕竟，Internet 正在我们身边以不可思议的速度发展着，如果一个程序员在设计编写他下一个程序的时候，根本没有考虑到网络，考虑到Internet，那么，可以说，他的设计很难成功。 
3 Linux的进程和Win32的进程/线程比较 
　　 熟悉WIN32编程的人一定知道，WIN32的进程管理方式与Linux上有着很大区别，在UNIX里，只有进程的概念，但在WIN32里却还有一个"线程"的概念，那么Linux和WIN32在这里究竟有着什么区别呢？ 
　　 WIN32里的进程/线程是继承自OS/2的。在WIN32里，"进程"是指一个程序，而"线程"是一个"进程"里的一个执行"线索"。从核心上讲，WIN32的多进程与Linux并无多大的区别，在WIN32里的线程才相当于Linux的进程，是一个实际正在执行的代码。但是，WIN32里同一个进程里各个线程之间是共享数据段的。这才是与Linux的进程最大的不同。

 

 

1. Linux与MS-DOS的区别

        在同一系统上运行Linux和MS-DOS已很普遍，但它们之间还是有较多区别的。

        就发挥处理器功能来说，MS-DOS没有完全发挥x86处理器的功能，而Linux完全在处理器保护模式下运行，并且发挥了处理器的所有特性。Linux可以直接访问计算机内的所有可用内存，提供完整的Unix接口，而MS-DOS只支持部分Unix的接口。

 

         就使用费用而言，Linux和MS-DOS是两种完全不同的实体。与其他商业操作系统相比，MS-DOS价格比较便宜，而且在PC机用户中有很大的占有率，任何其他PC机操作系统都很难达到MS-DOS的普及程度，因为其他操作系统的费用对大多数PC机用户来说都是一个不小的负担，而Linux是免费的，用户可以从Internet上或者其他途径获得它的版本，而且可以任意使用，不用考虑费用问题。

 

         就操作系统的功能来说，MS-DOS是单任务的操作系统，一旦用户运行了一个MS-DOS的应用程序，它就独占了系统的资源，用户不可能再同时运行其他应用程序，而Linux是多任务的操作系统，用户可以同时运行多个应用程序。

 

2. Linux与OS/2、Windows的区别

        从发展的背景看，Linux与其他操作系统区别在于：Linux是从一个比较成熟的操作系统发展而来的，而其他操作系统(如Windows NT、Windows 2000等)都是自成体系，无对应的相依托的操作系统。这一区别使得Linux的用户能大大地从Unix团体贡献中获利。因为Unix是当今世界上使用最普遍、发展最成熟的操作系统之一，它是20世纪70年代中期发展起来的微机和巨型机的多任务系统，虽然有时接口比较混乱，并缺少相对集中的标准，但还是逐步发展壮大成为最广泛使用的操作系统之一。

 

       无论是Unix的作者还是Unix的用户，都认为只有Unix才是一个真正的操作系统，许多计算机系统(从个人计算机到超级计算机)都存在Unix版本，Unix的用户可以从很多方面得到支持和帮助。因此，Linux作为Unix的一个克隆，它的用户同样会得到相应的支持和帮助，Linux将直接拥有Unix在用户中建立的牢固地位。

 

        从使用费用上看，Linux与其他操作系统的区别在于：Linux是一种开放、免费的操作系统，而其他操作系统都是封闭的系统，需要有偿使用。这一区别使得我们不用花钱就能得到很多Linux的版本以及为其开发的应用软件。当我们访问Internet时，会发现几乎所有可用的自由软件都能够运行在Linux系统上，不同软件商对这些软件有不同的Unix实现方法。Unix的开发、发展商以开放系统的方式推动其标准化，但却没有一个公司来控制这种设计。

 

       因此，任何一个软件商(或开拓者)都能在某种Unix中实现这些标准。而OS/2和Windows等操作系统是具有版权的产品，其接口和设计均由某一公司控制，而且只有这些公司才有权实现其设计，它们都是在封闭的环境下发展的。