Linux系统编程之进程间通信

进程间通信方式

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。进程用户空间是相互独立的，一般而言是不能相互访问的。但很多情况下进程间需要互相通信，来完成系统的某项功能。进程通过与内核及其它进程之间的互相通信来协调它们的行为。

IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。

以Linux中的C语言编程为例。

1、无名管道

特点：

1、它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。

2、它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。

3、它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

原型

#include <unistd.h>

       int pipe(int pipefd[2]);	// 返回值：若成功返回0，失败返回-1

当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。如下图：

要关闭管道只需将这两个文件描述符关闭即可。
  单个进程中的管道几乎没有任何用处。所以，通常调用 pipe 的进程接着调用 fork，这样就创建了父进程与子进程之间的 IPC 通道。如下图所示：

  若要数据流从父进程流向子进程，则关闭父进程的读端（fd[0]）与子进程的写端（fd[1]）；反之，则可以使数据流从子进程流向父进程。

学习例程

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>


int main()
{
        int pid;
        int fd[2];
        char buf[128]={0};
        //int pipe(int pipefd[2]);
        if(pipe(fd) == -1){
                printf("create pipe fail\n");
        }
        pid = fork();
        if(pid < 0){
                printf("create child fail\n");
        }else if(pid > 0){
                printf("this is father\n");

                close(fd[0]);
                write(fd[1],"hello this is form father",strlen("hello this is form father"));
                wait(NULL);
        }else{
                printf("this is child\n");
                close(fd[1]);
                read(fd[0],buf,128);
                printf("read buf is :%s\n",buf);
                exit(0);
        }


        return 0;
}

运行结果：

this is father
this is child
read buf is :hello this is form father

2、命名管道

特点

FIFO可以在无关的进程之间交换数据，与无名管道不同。

FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

原型

#include <sys/types.h>
#include <sys/stat.h>

       int mkfifo(const char *pathname, mode_t mode);

返回值：成功返回0，出错返回-1
  其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。

当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

  若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
  若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

学习例程

  FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且“先进先出”。下面的例子演示了使用 FIFO 进行 IPC 的过程：
read.c:

#include<errno.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
        int nread;
        int i;
        char buf[30]={0};
        //int mkfifo(const char *pathname, mode_t mode);        
        if(mkfifo("./file",0600) == -1 && errno != EEXIST){
                perror("why");
        }
        int fd = open("./file",O_RDONLY);
        printf("read open success\n");
        for(i=0;i<5;i++){
                sleep(1);
                nread = read(fd,buf,30);
                printf("read %d byte ;read context:%s\n",nread,buf);
        }
        close(fd);
        return 0;
}

write.c

#include <sys/stat.h>
#include<errno.h>
#include <fcntl.h>
#include<string.h>
#include <unistd.h>

int main()
{
        int i;
        char *str = "this is write";
        //int mkfifo(const char *pathname, mode_t mode);        
        if(mkfifo("./file",0600) == -1 && errno != EEXIST){
                perror("why");
        }
        int fd = open("./file",O_WRONLY);
        printf("write success\n");
        for(i=0;i<5;i++){
                sleep(1);
                 write(fd,str,strlen(str));
        }
        close(fd);
        return 0;
}

运行结果：
read端：

read open success
read 13 byte ;read context:this is write
read 13 byte ;read context:this is write
read 13 byte ;read context:this is write
read 13 byte ;read context:this is write
read 13 byte ;read context:this is write

write端：

write success

  上述例子可以扩展成 客户进程—服务器进程 通信的实例，write.c的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，read.c类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：

3、消息队列

  消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。

特点

  消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。

  消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。

  消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

原型

1 #include <sys/msg.h>
2 // 创建或打开消息队列：成功返回队列ID，失败返回-1
3 int msgget(key_t key, int flag);
4 // 添加消息：成功返回0，失败返回-1
5 int msgsnd(int msqid, const void *ptr, size_t size, int flag);
6 // 读取消息：成功返回消息数据的长度，失败返回-1
7 int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
8 // 控制消息队列：成功返回0，失败返回-1
9 int msgctl(int msqid, int cmd, struct msqid_ds *buf);

在以下两种情况下，msgget将创建一个新的消息队列：

  如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。
  key参数为IPC_PRIVATE。
关于key的值我们可以直接随便写一个整数如1234等；但是大多数情况下还是使用ftok函数来获取key值。

ftok函数

系统IPC键值的格式转换函数

系统建立IPC通讯 （消息队列、信号量和共享内存） 时必须指定一个ID值。通常情况下，该id值通过ftok函数得到。

头文件：

#include <sys/types.h>
#include <sys/ipc.h>

函数原型：

key_t ftok( const char * fname, int id )

fname就是你指定的文件名（已经存在的文件名），一般使用当前目录
id是子序号。虽然是int类型，但是只使用8bits(1-255）。

  在一般的UNIX实现中，是将文件的索引节点号取出，前面加上子序号得到key_t的返回值。如指定文件的索引节点号为65538，换算成16进制为0x010002，而你指定的ID值为38，换算成16进制为0x26，则最后的key_t返回值为0x26010002。
查询文件索引节点号的方法是： ls -i
这里我们初学者学会用就可以了，不一定搞那么懂。

函数msgrcv在读取消息队列时，type参数有下面几种情况：

  type == 0，返回队列中的第一个消息；
  type > 0，返回队列中消息类型为 type 的第一个消息；
  type < 0，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。
  可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。

学习例程

msgget.c

#include<errno.h>
#include <fcntl.h>
#include<string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>



struct msgbuf
{
        long mtype;
        char mtext[128];
};

int main()
{
        struct msgbuf sentBuf={999,"thanks for your read"};;
        struct msgbuf readBuf;
        
        key_t key;
        key = ftok(".",'x');   //ftok函数获取键值
        printf("key is %x\n",key);
        
        int msgId = msgget(key,IPC_CREAT|0777);
        if(msgId==-1){
                printf("get quen fail\n");
        }

        msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);
        printf("read from que %s\n",readBuf.mtext);

        msgsnd(msgId,&sentBuf,sizeof(sentBuf.mtext),0);
        printf("sent over\n");

        msgctl(msgId,IPC_RMID,NULL);//清除消息队列。
        return 0;
}

msgsent.c

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include<errno.h>
#include <fcntl.h>
#include<string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>

struct msgbuf
{
        long mtype;
        char mtext[128];
};

int main()
{
        struct msgbuf readBuf;
        struct msgbuf sentBuf={888,"this is message from quen"};
    
        key_t key;
        key = ftok(".",'x');
        printf("key is %x\n",key);
        
        int msgId = msgget(key,IPC_CREAT|0777);
        if(msgId==-1){
                printf("get quen fail\n");
        }
        msgsnd(msgId,&sentBuf,sizeof(sentBuf.mtext),0);
        printf("sent over\n");

        msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),999,0);
        printf("read from quen %s\n",readBuf.mtext);

        msgctl(msgId,IPC_RMID,NULL);

        return 0;
}

运行结果：
msgget.c:

key is 78012d58
read from que this is message from quen
sent over

msgsent.c

key is 78012d58
sent over
read from quen thanks for your read

4、共享内存

共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。

特点

共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。

因为多个进程可以同时操作，所以需要进行同步。

信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

原型

1 #include <sys/shm.h>
2 // 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
3 int shmget(key_t key, size_t size, int flag);
4 // 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
5 void *shmat(int shm_id, const void *addr, int flag);
6 // 断开与共享内存的连接：成功返回0，失败返回-1
7 int shmdt(void *addr); 
8 // 控制共享内存的相关信息：成功返回0，失败返回-1
9 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

  当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。

  当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。

  shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。

  shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）

学习例程

shmread.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
        //int shmget(key_t key, size_t size, int shmflg);
int main()
{
        key_t key;
        key = ftok(".",'x');
        printf("key is %x\n",key);
        int shmid;
        shmid = shmget(key,1024*4,0);
        if(shmid==-1){
                printf("shmget fail\n");
                exit(-1);
        }

        char *shmaddr;
        //void *shmat(int shmid, const void *shmaddr, int shmflg);
        shmaddr = shmat(shmid,0,0);
        printf("shmat success\n");

        printf("data : %s\n",shmaddr);

        //int shmdt(const void *shmaddr);
        shmdt(shmaddr);


        printf("quit\n");
        return 0;
}

shmwrite.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include <unistd.h>
//int shmget(key_t key, size_t size, int shmflg);
int main()
{
        key_t key;
        key = ftok(".",'x');
        printf("key is %x\n",key);
        int shmid;
        shmid = shmget(key,1024*4,IPC_CREAT|0666);
        if(shmid==-1){
                printf("shmget fail\n");
                exit(-1);
        }
        char *shmaddr;
        //void *shmat(int shmid, const void *shmaddr, int shmflg);
        shmaddr = shmat(shmid,0,0);
        printf("shmat success\n");

        strcpy(shmaddr,"xiexiong hen shuai");
        sleep(5);

        //int shmdt(const void *shmaddr);
        shmdt(shmaddr);

        //int shmctl(int shmid, int cmd, struct shmid_ds *buf);
        shmctl(shmid,IPC_RMID,0);

        printf("quit\n");
        return 0;
}

运行结果：
shmread.c

key is 78012d58
shmat success
data : xiexiong hen shuai
quit

shmwrite.c

key is 78012d58
shmat success
quit

5、信号

信号的内容相对比较复杂，这里我参考的是这篇文章，说的比较详细: Linux 信号（signal）.

学习例程

以下例程是简单的通过信号来发送一些整型数的信息。

get.c：

#include<stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>

//int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

void handler(int signum,siginfo_t *info,void *context)
{
        printf("get signum %d\n",signum);
        if(context!=NULL){
                printf("get data %d\n",info->si_int);
                printf("get data %d\n",info->si_value.sival_int);
                printf("get data over\n");
        }
}

int main()
{
        struct sigaction act;
        act.sa_sigaction = handler;
        act.sa_flags = SA_SIGINFO;
        printf("pid %d \n",getpid());
        sigaction(SIGUSR1,&act,NULL);


        while(1);
        return 0;
}

sent.c

#include<stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc,char **argv)
{
        int signum;
        int pid;

        signum = atoi(argv[1]);
        pid = atoi(argv[2]);
        printf("signum %d pid %d\n",signum,pid);

        union sigval value;
        value.sival_int = 100;
        //int sigqueue(pid_t pid, int sig, const union sigval value);
        sigqueue(pid,signum,value);

        printf("pid %d sent signal over\n",getpid());
        return 0;
}

运行结果：
get.c:

pid 2837 
get signum 10
get data 100
get data 100
get data over

sent.c:
xiexiong@ubuntu:~$ ./a.out 10 2837

signum 10 pid 2837
pid 2846 sent signal over

6、信号量

  信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制,防止某进程在访问资源时其它进程也访问该资源.因此,主要作为进程间以及同一个进程内不同线程之间的同步手段.

特点

  信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。

  信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。

  每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。

  支持信号量组。

原型

  最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。

  Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。

1 #include <sys/sem.h>
2 // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
3 int semget(key_t key, int num_sems, int sem_flags);
4 // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
5 int semop(int semid, struct sembuf semoparray[], size_t numops);  
6 // 控制信号量的相关信息
7 int semctl(int semid, int sem_num, int cmd, ...);

当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1； 如果是引用一个现有的集合，则将num_sems指定为 0 。
在semop函数中，sembuf结构的定义如下：

1 struct sembuf 
2 {
3     short sem_num; // 信号量组中对应的序号，0～sem_nums-1
4     short sem_op;  // 信号量在一次操作中需要改变的数据
5     short sem_flg; // IPC_NOWAIT, SEM_UNDO
6 }

其中 sem_op 是一次操作中的信号量的改变量，通常是两个数，一个是-1，即P（等待）操作一个是+1，即V（发送信号）操作。：

若sem_op > 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则唤醒它们。

若sem_op < 0，请求 sem_op 的绝对值的资源。

  如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。
  当相应的资源数不能满足请求时，这个操作与sem_flg有关。
  sem_flg 指定IPC_NOWAIT，则semop函数出错返回EAGAIN。
  sem_flg 没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
     当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem_op的绝对值。成功返回；
     此信号量被删除，函数smeop出错返回EIDRM；
     进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR
若sem_op == 0，进程阻塞直到信号量的相应值为0：

  当信号量已经为0，函数立即返回。
  如果信号量的值不为0，则依据sem_flg决定函数动作：
     sem_flg指定IPC_NOWAIT，则出错返回EAGAIN。
     sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
        信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；
        此信号量被删除，函数smeop出错返回EIDRM；
        进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
在semctl函数中的命令有多种，这里就说两个常用的：

  SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
  IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

学习例程

本例程通过信号量来控制子进程一直在父进程之前运行，因为父进程一开始就进行了P操作即等待，只有当子进程中完成了想要执行的代码后才进行V操作释放资源，此时父进程才能执行后面的程序。

1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<sys/sem.h>
  4 
  5 // 联合体，用于semctl初始化
  6 union semun
  7 {
  8     int              val; /*for SETVAL*/
  9     struct semid_ds *buf;
 10     unsigned short  *array;
 11 };
 12 
 13 // 初始化信号量
 14 int init_sem(int sem_id, int value)
 15 {
 16     union semun tmp;
 17     tmp.val = value;
 18     if(semctl(sem_id, 0, SETVAL, tmp) == -1)
 19     {
 20         perror("Init Semaphore Error");
 21         return -1;
 22     }
 23     return 0;
 24 }
 25 
 26 // P操作:
 27 //    若信号量值为1，获取资源并将信号量值-1 
 28 //    若信号量值为0，进程挂起等待
 29 int sem_p(int sem_id)
 30 {
 31     struct sembuf sbuf;
 32     sbuf.sem_num = 0; /*序号*/
 33     sbuf.sem_op = -1; /*P操作*/
 34     sbuf.sem_flg = SEM_UNDO;
 35 
 36     if(semop(sem_id, &sbuf, 1) == -1)
 37     {
 38         perror("P operation Error");
 39         return -1;
 40     }
 41     return 0;
 42 }
 43 
 44 // V操作：
 45 //    释放资源并将信号量值+1
 46 //    如果有进程正在挂起等待，则唤醒它们
 47 int sem_v(int sem_id)
 48 {
 49     struct sembuf sbuf;
 50     sbuf.sem_num = 0; /*序号*/
 51     sbuf.sem_op = 1;  /*V操作*/
 52     sbuf.sem_flg = SEM_UNDO;
 53 
 54     if(semop(sem_id, &sbuf, 1) == -1)
 55     {
 56         perror("V operation Error");
 57         return -1;
 58     }
 59     return 0;
 60 }
 61 
 62 // 删除信号量集
 63 int del_sem(int sem_id)
 64 {
 65     union semun tmp;
 66     if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
 67     {
 68         perror("Delete Semaphore Error");
 69         return -1;
 70     }
 71     return 0;
 72 }
 73 
 74 
 75 int main()
 76 {
 77     int sem_id;  // 信号量集ID
 78     key_t key;  
 79     pid_t pid;
 80 
 81     // 获取key值
 82     if((key = ftok(".", 'z')) < 0)
 83     {
 84         perror("ftok error");
 85         exit(1);
 86     }
 87 
 88     // 创建信号量集，其中只有一个信号量
 89     if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
 90     {
 91         perror("semget error");
 92         exit(1);
 93     }
 94 
 95     // 初始化：初值设为0资源被占用
 96     init_sem(sem_id, 0);
 97 
 98     if((pid = fork()) == -1)
 99         perror("Fork Error");
100     else if(pid == 0) /*子进程*/ 
101     {
102         sleep(2);
103         printf("Process child: pid=%d\n", getpid());
104         sem_v(sem_id);  /*释放资源*/
105     }
106     else  /*父进程*/
107     {
108         sem_p(sem_id);   /*等待资源*/
109         printf("Process father: pid=%d\n", getpid());
110         sem_v(sem_id);   /*释放资源*/
111         del_sem(sem_id); /*删除信号量集*/
112     }
113     return 0;
114 }

运行结果：

Process child: pid=2913
Process father: pid=2912

上面的例子如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。

7、总结

(1) 管道（pipe）：
   管道允许一个进程和另一个与它有共同祖先的进程之间进行通信；

(2) 命名管道（FIFO）：
  类似于管道，但是它可以用于任何两个进程之间的通信，命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建；

（3）消息队列（message queue）：
  消息队列是消息的连接表，包括POSIX消息对和System V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能成该无格式字节流以及缓冲区大小受限等缺点；

（4）共享内存 （shared memory）：
  它使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。这是针对其他通信机制运行效率较低而设计的。它往往与其他通信机制，如信号量结合使用，以达到进程间的同步及互斥；

(5) 信号（signal）：
  信号是比较复杂的通信方式，用于通知接收进程有某种事情发生，除了用于进程间通信外，进程还可以发送信号给进程本身；Linux除了支持UNIX早期信号语义函数signal外，还支持语义符合POSIX.1标准的信号函数sigaction(实际上，该函数是基于BSD的，BSD即能实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数的功能);

(6) 信号量（semaphore）：
  信号量主要作为进程间以及同进程不同线程之间的同步手段；本身不进行数据的传递。

进程间通信应用场景：
数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。

共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。

通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。

资源共享：多个进程之间共享同样的资源。为了作到这一点，需要内核提供锁和同步机制。

进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。