Linux下的多进程编程

什么是一个进程？当用户敲入命令执行一个程序的时候，对系统而言，它将启动一个进程。但和程序不同的是，在这个进程中，系统可能需要再启动一个或多个进程来完成独立的多个任务。多进程编程的主要内容包括进程控制和进程间通信。

 

1       Linux下进程的结构

Linux下一个进程在内存里有三部分的数据，就是"代码段"、"堆栈段"和"数据段"。这三个部分也是构成一个完整的执行序列的必要的部分。

 

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

 

2       Linux下的进程控制

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

 

2.1    fork()

fork在英文中是"分叉"的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就"分叉"了，所以这个名字取得很形象。下面就看看如何具体使用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函数返回了子程序的进程号，而对于子程序，fork函数则返回零。在操作系统中，我们用ps函数就可以看到不同的进程号，对父进程而言，它的进程号是由比它更低层的系统调用赋予的，而对于子进程而言，它的进程号即是fork函数对父进程的返回值。在程序设计中，父进程和子进程都要调用函数fork()下面的代码，而我们就是利用fork()函数对父子进程的不同返回值用if……else……语句来实现让父子进程完成不同的功能。我们看到，上面例子执行时两条信息是交互无规则的打印出来的，这是父子进程独立执行的结果，虽然我们的代码似乎和串行的代码没有什么区别。

 

读者也许会问，如果一个大程序在运行中，它的数据段和堆栈都很大，一次fork就要复制一次，那么fork的系统开销不是很大吗？无论是数据段还是堆栈段都是由许多"页"构成的，fork函数复制这两个段，只是"逻辑"上的，并非"物理"上的，也就是说，实际执行fork时，物理空间上两个进程的数据段和堆栈段都还是共享着的，当有一个进程写了某个数据时，这时两个进程之间的数据才有了区别，系统就将有区别的"页"从物理上也分开。系统在空间上的开销就可以达到最小。

 

下面演示一个足以"搞死"Linux的小程序，其源代码非常简单：

void main()

{

　　for( ; ; ) fork();

}

这个程序什么也不做，就是死循环地fork，其结果是程序不断产生进程，而这些进程又不断产生新的进程，很快，系统的进程就满了，系统就被这么多不断产生的进程"撑死了"。当然只要系统管理员预先给每个用户设置可运行的最大进程数，这个恶意的程序就完成不了企图了。

 

2.2    exec( )函数族

下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec函数族。系统调用execve()对当前进程进行替换，替换者为一个指定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变量（envp）。exec函数族当然不止一个，但它们大致相同，在Linux中，它们分别是：execl，execlp，execle，execv，execve和execvp，下面我只以execlp为例。

 

一个进程一旦调用exec类函数，它本身就"死亡"了，系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数据段与堆栈段，唯一留下的，就是进程号，也就是说，对系统而言，还是同一个进程，不过已经是另一个程序了。

 

那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话，怎么办呢？那就是结合fork与exec的使用。下面一段代码显示如何启动运行其它程序：

 

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 );

                }

        }

}

 

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

 

在这一节里，我们还要讲讲system()和popen()函数。system()函数先调用fork()，然后再调用exec()来执行用户的登录shell，通过它来查找可执行文件的命令并分析参数，最后它么使用wait()函数族之一来等待子进程的结束。函数popen()和函数system()相似，不同的是它调用pipe()函数创建一个管道，通过它来完成程序的标准输入和标准输出。

 

 

3       Linux下的进程间通信

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

 

3.1    管道

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

 

无名管道由pipe()函数创建：

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);

}

 

3.2    消息队列

消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它。

 

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/msg.h>

#include <sys/stat.h>

#define MSG_FILE "server-ipc-test.c"

#define BUFFER 255

#define PERM S_IRUSR|S_IWUSR

 

struct msgtype {

long mtype;

char buffer[BUFFER+1];

};

 

int main(int argc，char **argv)

{

        struct msgtype msg;

        key_t key;

        int msgid;

       

        if(argc!=2)

        {

                fprintf(stderr，"Usage:%s string/n/a"，argv[0]);

                exit(1);

        }

 

        if((key=ftok(MSG_FILE，'a'))==-1)

        {

                fprintf(stderr，"Creat Key Error:%s/a/n"，strerror(errno));

                exit(1);

        }

 

        if((msgid=msgget(key，PERM))==-1)

        {

                fprintf(stderr，"Creat Message Error:%s/a/n"，strerror(errno));

                exit(1);

        }

       

        msg.mtype=1;

        strncpy(msg.buffer，argv[1]，BUFFER);

        msgsnd(msgid，&msg，sizeof(struct msgtype)，0);

        memset(&msg，'/0'，sizeof(struct msgtype));

        msgrcv(msgid，&msg，sizeof(struct msgtype)，2，0);

        fprintf(stderr，"Client receive:%s/n"，msg.buffer);

        exit(0);

}

 

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/stat.h>

#include <sys/msg.h>

#define MSG_FILE "server-ipc-test.c"

#define BUFFER 255

#define PERM S_IRUSR|S_IWUSR

 

struct msgtype {

long mtype;

char buffer[BUFFER+1];

};

 

int del_msg(int msgid)

{

/* 消息队列并不随程序的结束而被删除，如果我们没删除的话(将1改为0)

可以用ipcs命令查看到消息队列，用ipcrm可以删除消息队列

*/

#if 1

return msgctl(msgid，0，IPC_RMID);

#endif

}

 

int main()

{

        struct msgtype msg;

        key_t key;

        int msgid;

       

        if((key=ftok(MSG_FILE，'a'))==-1)

        {

                fprintf(stderr，"Creat Key Error:%s/a/n"，strerror(errno));

                exit(1);

        }

 

        if((msgid=msgget(key，PERM|IPC_CREAT|IPC_EXCL))==-1)

        {

                fprintf(stderr，"Creat Message Error:%s/a/n"，strerror(errno));

                exit(1);

        }

       

        while(1)

        {

                msgrcv(msgid，&msg，sizeof(struct msgtype)，1，0);

                fprintf(stderr，"Server Receive:%s/n"，msg.buffer);

                msg.mtype=2;

                msgsnd(msgid，&msg，sizeof(struct msgtype)，0);

        }

 

        // sailing add to solve Creat Message Error: file exist

        del_msg(msgid);

        exit(0);

}

 

 

3.3    共享内存

共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存。常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。

 

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

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等来实现。

 

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/shm.h>

#define PERM S_IRUSR|S_IWUSR

 

int main(int argc,char **argv)

{

        int shmid;

        char *p_addr,*c_addr;

        if(argc!=2)

        {

                fprintf(stderr,"Usage:%s/n/a",argv[0]);

                exit(1);

        }

       

        if((shmid=shmget(IPC_PRIVATE,1024,PERM))==-1)

        {

                fprintf(stderr,"Create Share Memory Error:%s/n/a",strerror(errno));

                exit(1);

        }

       

        if(fork()) //父进程

        {

                p_addr=shmat(shmid,0,0);

                memset(p_addr,'/0',1024);

                strncpy(p_addr,argv[1],1024);

                exit(0);

        }

        else //子进程

        {

                c_addr=shmat(shmid,0,0);

                printf("Client get %s/n/a",c_addr);

                exit(0);

        }

}

 

 

3.4    信号量

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

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

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

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

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

 

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

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关键字。

 

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);

}