Linux下的多进程编程

1. 动态性：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的。
2. 并发性：任何进程都可以同其他进程一起并发执行
3. 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位；
4. 异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进
5. 结构特征：进程由程序、数据和进程控制块三部分组成。

多个不同的进程可以包含相同的程序：一个程序在不同的数据集里就构成不同的进程，能得到不同的结果；但是执行过程中，程序不能发生改变。

1.4进程切换

1.5Linux下进程的结构

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

2、fork()函数

在Linux下产生新的进程的系统调用就是fork函数。fork是最难理解的概念之一：它执行一次却返回两个值。fork函数是Unix系统最杰出的成就之一，它是七十年代UNIX早期的开发者经过长期在理论和实践上的艰苦探索后取得的成果，一方面，它使操作系统在进程管理上付出了最小的代价，另一方面，又为程序员提供了一个简洁明了的多进程方法。与DOS和早期的Windows不同，Unix/Linux系统是真正实现多任务操作的系统，可以说，不使用多进程编程，就不能算是真正的Linux环境下编程。

示例：

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 parent process\n");
    }
}

程序运行后，就能看到屏幕上交替出现子进程与父进程各打印出的一千条信息了。如果程序还在运行中，你用ps命令就能看到系统中有两个它在运行了。  
那么调用这个fork函数时发生了什么呢？一个程序一调用fork函数，系统就为一个新的进程准备了前述三个段，首先，系统让新的进程与旧的进程使用同一个代码段，因为它们的程序还是相同的，对于数据段和堆栈段，系统则复制一份给新的进程，这样，父进程的所有数据都可以留给子进程，但是，子进程一旦开始运行，虽然它继承了父进程的一切数据，但实际上数据却已经分开，相互之间不再有影响了，也就是说，它们之间不再共享任何数据了。而如果两个进程要共享什么数据的话，就要使用另一套函数（shmget，shmat，shmdt等）来操作。现在，已经是两个进程了，对于父进程，fork函数返回了子程序的进程号，而对于子程序，fork函数则返回零，这样，对于程序，只要判断fork函数的返回值，就知道自己是处于父进程还是子进程中。  

有个疑问：如果一个大程序在运行中，它的数据段和堆栈都很大，一次fork就要复制一次，那么fork的系统开销不是很大吗？

其实Linux自有其解决的办法，大家知道，一般CPU都是以“页”为单位分配空间的，象INTEL的CPU，其一页在通常情况下是4K字节大小，而无论是数据段还是堆栈段都是由许多“页”构成的，fork函数复制这两个段，只是“逻辑”上的，并非“物理”上的，也就是说，实际执行fork时，物理空间上两个进程的数据段和堆栈段都还是共享着的，当有一个进程写了某个数据时，这时两个进程之间的数据才有了区别，系统就将有区别的“页”从物理上也分开。系统在空间上的开销就可以达到最小。  

如何搞死Linux系统，看下面的小程序：

void main()  
{  
       for(;;) fork();  
}  

这个程序什么也不做，就是死循环地fork，其结果是程序不断产生进程，而这些进程又不断产生新的进程，很快，系统的进程就满了，系统就被这么多不断产生的进程"撑死了"。用不着是root权限，任何人运行上述程序都足以让系统死掉。哈哈，但这不是Linux不安全的理由，因为只要系统管理员足够聪明，他（或她）就可以预先给每个用户设置可运行的最大进程数，这样，只要不是root，任何能运行的进程数也许不足系统总的能运行和进程数的十分之一。这样，系统管理员就能对付上述恶意的程序了。  

2.1如何启动另一程序的执行

下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec类的函数，exec类的函数不止一个，但大致相同，在Linux中，它们分别是：execl，execlp，execle，execv，execve和execvp，下面以execlp为例，其它函数究竟与execlp有何区别，请通过man exec命令来了解它们的具体情况。  一个进程一旦调用exec类函数，它本身就“死亡”了，系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数据段与堆栈段，唯一留下的，就是进程号，也就是说，对系统而言，还是同一个进程，不过已经是另一个程序了。（不过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);
        }
    }
}

此程序从终端读入命令并执行之，执行完成后，父进程继续等待从终端读入命令。熟悉DOS和WINDOWS系统调用的朋友一定知道DOS/WINDOWS也有exec类函数，其使用方法是类似的，但DOS/WINDOWS还有spawn类函数，因为DOS是单任务的系统，它只能将“父进程”驻留在机器内再执行“子进程”，这就是spawn类的函数。WIN32已经是多任务的系统了，但还保留了spawn类函数，WIN32中实现spawn函数的方法同前述Linux中的方法差不多，开设子进程后父进程等待子进程结束后才继续运行。Linux在其一开始就是多任务的系统，所以从核心角度上讲不需要spawn类函数。  
另外，有一个更简单的执行其它程序的函数system，它是一个较高层的函数，实际上相当于在SHELL环境下执行一条命令，而exec类函数则是低层的系统调用。

3、Linux下的进程间通信 

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

3.1管道 

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

#include <unistd.h> 
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 <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); 

shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。
使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_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);
}

2.5套接口

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

文章摘选：http://blog.csdn.net/wallwind/article/details/6899493