Linux进程管理-调度-通信-

参考：http://blog.csdn.net/hguisu/article/details/6128274 

1. 进程的概念

     Linux是一个多用户多任务的操作系统。多用户是指多个用户可以在同一时间使用同一个linux系统；多任务是指在Linux下可以同时执行多个任务，更详细的说，linux采用了分时管理的方法，所有的任务都放在一个队列中，操作系统根据每个任务的优先级为每个任务分配合适的时间片，每个时间片很短，用户根本感觉不到是多个任务在运行，从而使所有的任务共同分享系统资源，因此linux可以在一个任务还未执行完时，暂时挂起此任务，又去执行另一个任务，过一段时间以后再回来处理这个任务，直到这个任务完成，才从任务队列中去除。这就是多任务的概念。
    上面说的是单CPU多任务操作系统的情形，在这种环境下，虽然系统可以运行多个任务，但是在某一个时间点，CPU只能执行一个进程，而在多CPU多任务的操作系统下，由于有多个CPU，所以在某个时间点上，可以有多个进程同时运行。
   进程的的基本定义是：在自身的虚拟地址空间运行的一个独立的程序，从操作系统的角度来看，所有在系统上运行的东西，都可以称为一个进程。

     需要注意的是：程序和进程是有区别的，进程虽然有程序产生，但是它并不是程序，程序是一个进程指令的集合，它可以启用一个或多个进程，同时，程序只占用磁盘空间，而不占用系统运行资源，而进程仅仅占用系统内存空间，是动态的、可变的，关闭进程，占用的内存资源随之释放。
例如，用户在linux上打开一个文件、就会产生一个打开文件的进程，关闭文件，进程也随机关闭。如果在系统上启动一个服务，例如启动tomcat服务，就会产生一个对应的Java的进程。而如果启动apache服务，许多用户来同时请求httpd服务，apache服务器将会创建有多个httpd进程来对其进行服务 。

2. 进程分类

   按照进程的功能和运行的程序分类，进程可划分为两大类：
 系统进程：可以执行内存资源分配和进程切换等管理工作；而且，该进程的运行不受用户的干预，即使是root用户也不能干预系统进程的运行。
 用户进程：通过执行用户程序、应用程序或内核之外的系统程序而产生的进程，此类进程可以在用户的控制下运行或关闭。
   针对用户进程，又可以分为交互进程、批处理进程和守护进程三类。
    1)交互进程：由一个shell终端启动的进程，在执行过程中，需要与用户进行交互操作，可以运行于前台，也可以运行在后台。
    2)批处理进程：该进程是一个进程集合，负责按顺序启动其他的进程。
   3)守护进程：守护进程是一直运行的一种进程，经常在linux系统启动时启动，在系统关闭时终止。它们独立于控制终端并且周期性的执行某种任务或等待处理某些发生的事件。例如httpd进程，一直处于运行状态，等待用户的访问。还有经常用的crond进程，这个进程类似与windows的计划任务，可以周期性的执行用户设定的某些任务。

3. 进程的属性

     进程ID（PID)：是唯一的数值，用来区分进程；
     父进程和父进程的ID（PPID)；
     启动进程的用户ID（UID）和所归属的组（GID）；
     进程状态：状态分为运行R、休眠S、僵尸Z；
     进程执行的优先级；
     进程所连接的终端名；
     进程资源占用：比如占用资源大小（内存、CPU占用量）；

      使用shell命令：ps -aux                    

      ps命令输出字段的含义

     USER，进程所有者的用户名。
     PID，进程号，可以唯一标识该进程。
     CPU，进程自最近一次刷新以来所占用的CPU时间和总时间的百分比。
     MEM，进程使用内存的百分比。
     VSZ，进程使用的虚拟内存大小，以K为单位。
     RSS，进程占用的物理内存的总数量，以K为单位。
     TTY，进程相关的终端名。
     STAT，进程状态，用(R–运行或准备运行；S–睡眠状态（Sleep）；I–空闲（idle）；Z–僵死（zombie）；D–不间断睡眠；W-进程没有驻留页；T停止或跟踪。)这些字母来表示。
     START，进程开始运行时间。
     TIME，进程使用的总CPU时间。
     COMMAND，被执行的命令行。

4. Linux进程的结构

         Linux中一个进程在内存里有三部分数据，就是“数据段”、“堆栈段”和“代码段”。基于I386兼容的中央处理器，都有上述三种段寄存器，以方便操作系统的运行，如图所示：

         

         代码段：是存放了程序代码的数据，即存放CPU执行指令的集合。假如机器中有数个进程运行相同的一个程序，那么它们就可以使用同一个代码段。

         数据段：存放程序的全局变量、常数及动态数据分配的数据空间，即被执行指令所访问的数据。

         堆栈段:  存放的就是子程序的返回地址、子程序的参数及程序的局部变量。堆栈段包含在进程控制块PCB（Process Control Block）中。PCB处于进程核心堆栈的底部，不需要额外分配空间。堆栈段包括堆和栈：

        堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）

        栈（stack）：栈是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味这在数据段中存放变量）。除此以外在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也回被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上将我们可以把堆栈看成一个临时数据寄存、交换的内存区。

5. Linux进程的状态

我们先看Linux的进程五态模型及其转换：

   

这些状态是task_struct结构的一部分：

1  R (task_running) : 可执行状态

       只有在该状态的进程才可能在CPU上运行。而同一时刻可能有多个进程 处于可执行状态，这些进程的task_struct结构（进程控制块）被放入对应CPU的 可执行队列中（一个进程最多只能出现在一个CPU的可执行队列中）。进程调度器的任务就是从各个CPU的可执行队列中分别选择一个进程在该CPU上运行。

       很多操作系统教科书将正在CPU上执行的进程定义为RUNNING状态、而将可执行但是尚未被调度执行的进程定义为READY状态，这两种状态在linux下统一为 TASK_RUNNING状态。

2  S (task_interruptible): 可中断的睡眠状态

       处于这个状态的进程因为等待某某事件的发生（比如等待socket连 接、等待信号量），而被挂起。这些进程的task_struct结构被放入对应事件的等待队列中。当这些事件发生时（由外部中断触发、或由其他进程触发），对应的等 待队列中的一个或多个进程将被唤醒。

       通过ps命令我们会看到，一般情况下，进程列表中的绝大多数进程都处于task_interruptible状态（除非机器的负载很高）。毕竟CPU就这么一两个，进程动辄几十上百个，如果不是绝大多数进程都在睡眠，CPU又怎么响应得过来。

3  D (task_uninterruptible): 不可中断的睡眠状态

       与task_interruptible状态类似，进程处于睡眠状态，但是此刻进程是不可中断的。不可中断，指的并不是CPU不响应外部硬件的中断，而是指进程不响应异步信号。
       绝大多数情况下，进程处在睡眠状态时，总是应该能够响应异步信号的。但是uninterruptible sleep 状态的进程不接受外来的任何信号，因此无法用kill杀掉这些处于D状态的进程，无论是”kill”, “kill -9″还是”kill -15″，这种情况下，一个可选的方法就是reboot。

       处于uninterruptible sleep状态的进程通常是在等待IO，比如磁盘IO，网络IO，其他外设IO，如果进程正在等待的IO在较长的时间内都没有响应，那么就被ps看到了，同时也就意味着很有可能有IO出了问题，可能是外设本身出了故障，也可能是比如挂载的远程文件系统已经不可访问了.

       而task_uninterruptible状态存在的意义就在于，内核的某些处理流程是不能被打断的。如果响应异步信号，程序的执行流程中就会被插入一段用于处理异步信号的流程（这个插入的流程可能只存在于内核态，也可能延伸到用户态），于是原有的流程就被中断了。

       在进程对某些硬件进行操作时（比如进程调用read系统调用对某个设 备文件进行读操作，而read系统调用最终执行到对应设备驱动的代码，并与对应的物理设备进行交互），可能需要使用task_uninterruptible状态对进程进行保护，以避免进程与设备交互的过程被打断，造成设备陷入不可控的状态。这种情况下的task_uninterruptible状态总是非常短暂的，通过ps命 令基本上不可能捕捉到。

       我们通过vmstat 命令中procs下的b 可以来查看是否有处于uninterruptible 状态的进程。该命令只能显示数量。

4  T(task_stoppedor task_traced)：暂停状态或跟踪状态

       向进程发送一个sigstop信号，它就会因响应该信号而进入task_stopped状态（除非该进程本身处于task_uninterruptible状态而不响应信号）。（sigstop与sigkill信号一样，是非常强制的。不允许用户进程通过signal系列的系统调用重新设置对应的信号处理函数。）
       向进程发送一个sigcont信号，可以让其从task_stopped状态恢复到task_running状态。

       当进程正在被跟踪时，它处于task_traced这个特殊的状态。“正 在被跟踪”指的是进程暂停下来，等待跟踪它的进程对它进行操作。比如在gdb中对被跟踪的进程下一个断点，进程在断点处停下来的时候就处于task_traced状态。而在其他时候，被跟踪的进程还是处于前面提到的那些状态。     

       对于进程本身来说，task_stopped和task_traced状态很类似，都是表示进程暂停下来。
       而task_traced状态相当于在task_stopped之上多了一层保护，处于task_traced状态的进程不能响应sigcont信号而被唤醒。只能等到调试进程通过ptrace系统调用执行ptrace_cont、ptrace_detach等操作（通过ptrace系统调用的参数指定操作），或调试进程退出，被调试的进程才能恢复task_running状态。

 5 Z (task_dead -exit_zombie)：退出状态，进程成为僵尸进程

       在Linux进程的状态中，僵尸进程是非常特殊的一种，它是已经结束了的进程，但是没有从进程表中删除。太多了会导致进程表里面条目满了，进而导致系统崩溃，倒是不占用其他系统资源。     

       它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在 进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集，除此之外，僵尸进程不再占有任何内存空间。    

       进 程在退出的过程中，处于TASK_DEAD状态。在这个退出过程中，进程占有的所有资源将被回收，除了task_struct结构（以及少数资源）以外。于是进程就只剩 下task_struct这么个空壳，故称为僵尸。

       之所以保留task_struct，是因为task_struct里面保存了进程的退出码、以及一些统计信息。而其父进程很可能会关心这些信息。比如在shell中，$?变量就保存了最后一个退出的前台进程的退出码，而这个退出码往往被作为if语句的判断条件。
       当然，内核也可以将这些信息保存在别的地方，而将task_struct结构释放掉，以节省一些空间。但是使用task_struct结构更为方便，因为在内核中已经建立了从pid到task_struct查找关系，还有进程间的父子关系。释放掉task_struct，则需要建立一些新的数据结构，以便让父进程找到它的子进程的退出信息。

       子进程在退出的过程中，内核会给其父进程发送一个信号，通知父进程来“收 尸”。父进程可以通过wait系列的系统调用（如wait4、waitid）来等待某个或某些子进程的退出，并获取它的退出信息。然后wait系列的系统调用会顺便将子进程的尸体（task_struct）也释放掉。

       这 个信号默认是SIGCHLD，但是在通过clone系统调用创建 子进程时，可以设置这个信号。

       如果他的父进程没安装SIGCHLD信号处理函数调用wait或waitpid()等待子进程结束，又没有显式忽略该信号，那么它就一直保持僵尸状态，子进程的尸体（task_struct）也就无法释放掉。

       如果这时父进程结束了，那么init进程自动会接手这个子进程，为它收尸，它还是能被清除的。但是如果如果父进程是一个循环，不会结束， 那么子进程就会一直保持僵尸状态，这就是为什么系统中有时会有很多的僵尸进程。

       当进程退出的时候，会将它的所有子进程都托管给别的进程（使之成为别的进程的子进程）。托管的进程可能是退出进程所在进程组的下一个进程（如果存在的话），或者是1号进程。所以每个进程、每时每刻都有父进程 存在。除非它是1号进程。1号进程，pid为1的进程，又称init进程。

6. Linux的进程树

他们的关系是管理和被管理的关系，当父进程终止时，子进程也随之而终止。但子进程终止，父进程并不一定终止。比如httpd服务器运行时，我们可以杀掉其子进程，父进程并不会因为子进程的终止而终止。

一个进程创建新进程称为创建了子进程（Child Process）。相反地，创建子进程的进程称为父进程。所有进程追溯其祖先最终都会落到进程号为1的进程身上，这个进程叫做init进程，是内核自举后第一个启动的进程。init进程扮演终结父进程的角色。因为init进程永远不会被终止，所以系统总是可以确信它的存在，并在必要的时候以它为参照。如果某个进程在它衍生出来的全部子进程结束之前被终止，就会出现必须以init为参照的情况。此时那些失去了父进程的子进程就都会以init作为它们的父进程。如果执行一下ps -af命令，可以列出许多父进程ID为1的进程来。Linux提供了一条ps tree命令，允许用户查看系统内正在运行的各个进程之间的继承关系。直接在命令行中输入ps tree即可，程序会以树状结构方式列出系统中正在运行的各进程之间的继承关系。

1. 父进程和子进程

      系统允许一个进程创建新进程，新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。

      父进程和子进程的关系是管理和被管理的关系，当父进程终止时，子进程也随之而终止。但子进程终止，父进程并不一定终止。比如httpd服务器运行时，我们可以杀掉其子进程，父进程并不会因为子进程的终止而终止。

     * 父 进程与子进程的差异 ： 下图中，进程 A 为父进程，进程 B 为子进程

       

2. init进程

      整个linux系统的所有进程也是一个树形结构。树根是系统自动构造的，即在内核态下执行的0号进程，它是所有进程的祖先。由0号进程创建1号进程（内核态），1号负责执行内核的部分初始化工作及进行系统配置，并创建若干个用于高速缓存和虚拟主存管理的内核线程。随后，1号进程调用execve（）运行可执行程序init，并演变成用户态1号进程，即init进程。

      所有进程追溯其祖先最终都会落到进程号为1的init进程。init进程扮演终结父进程的角色。因为init进程永远不会被终止，所以系统总是可以确信它的存在，并在必要的时候以它为参照。

     init进程按照配置文件/etc/initab的要求，完成系统启动工作，创建编号为1号、2号...的若干终端注册进程getty。每个getty进程设置其进程组标识号，并监视配置到系统终端的接口线路。当检测到来自终端的连接信号时，getty进程将通过函数execve（）执行注册程序login，此时用户就可输入注册名和密码进入登录过程，如果成功，由login程序再通过函数execv（）执行shell，该shell进程接收getty进程的pid，取代原来的getty进程。再由shell直接或间接地产生其他进程。

上述过程可描述为：0号进程->1号内核进程->1号内核线程->1号用户进程（init进程）->getty进程->shell进程

            图 进程树的形成

      注意，上述过程描述中提到：1号内核进程调用执行init并演变成1号用户态进程（init进程），这里前者是init是函数，后者是进程。两者容易混淆，区别如下：

    1.init（）函数在内核态运行，是内核代码

    2.init进程是内核启动并运行的第一个用户进程，运行在用户态下。

     3.init（）函数调用execve（）从文件/etc/inittab中加载可执行程序init并执行，这个过程并没有使用调用do_fork()，因此两个进程都是1号进程。

linux系统启动后，第一个被创建的用户态进程就是init进程。它有两项使命：
       1、执行系统初始化脚本，创建一系列的进程（它们都是init进程的子孙）；
       2、在一个死循环中等待其子进程的退出事件，并调用waitid系统调用来完成“收尸”工作；

       init进程不会被暂停、也不会被杀死（这是由内核来保证的）。它在等待子进程退出的过程中处于task_interruptible状态，“收尸”过程中则处于task_running状态。

      * 进程的树状图：

      

7. Linux的进程控制

1. 进程的创建

       一个进程通过调用fork()系统调用创建一个子进程（调用fork()的是父进程）

       调用fork()时，创建的子进程复制父进程的data（数据段）,heap（推段）,stack段,共享父进程的Text段(Text段只读)

       

         fork调用将执行两次返回，它将从父进程和子进程中分别返回：

       从父进程返回时的返回值为子进程的PID，而从子进程返回时的返回值为0，并且返回都将执行fork之后的语句。调用出错时，返回值为-1

实例：

#include<sys/types.h>

#include<stdio.h>

#include<unistd.h>

int main( )

{

    pid_t pid；

    pid=fork()；

    if((pid)<0)

     {

           printf(“fork error!\n”);

           exit(1);

     }

     else if(pid=0)

           printf(“child process isprinting.IDis %d\n”,getpid());

     else

           printf(“parent process is printing. ID is%d\n”,getpid());

} 

运行结果：

[root@]# gcc fork_c.c -o fork_c

[root@]# ./ fork_c 

I am the child process,ID is 4238 I am the parent process,ID is 4237

因为 fork（）函数用于从已存在的进程中创建一个新的子进程，在 pid=fork();语句之前只有父进程在运行，而在 之后，父进程和新创建的子进程都在运行，子进程拷贝父进程的代码段，所以子进程中同样有

     if(pid<0)  

printf("error in fork!");

     else if(pid==0)      

printf("I am the child process,ID is %d\n",getpid());

       else   
               printf("I am the parent process,ID is %d\n",getpid());

我们再看看：

#include<unistd.h>

#include<unistd.h>

int   main( )

{

    pid_t pid；

    Intcount =0;

    pid=fork();

    Count++;

     Printf(“count=%d\n”,count);

     Return 0;

}

将被父子进程各执行一次，但是子进程执行时使自己的数据段里面的（这个数据段是从父进程那 copy过来的一模一样）count+1，同样父进程执行时使自己的数据段里面count+1，互不影响。

输出：Count=1
           Count=1

vfork的作用和fork基本相同，区别在于：
vfork并不完全复制父进程的数据段，而是和父进程共享数据段。
调用vfork对于父子进程的执行次序有所限制。调用vfork函数将使父进程挂起，直至子进程返回。
vfork 保证子进程先运行，在她调用 exec 或 exit 之后父进程才可能被调度运行。

2.进程的执行：

         使用exec族的函数执行新的程序，以新的子进程完全替代原有的进程。
int execl(const char *pathname,const char *arg,…);
int execlp(const char *filename,conxt char *arg,…);
int execle(const char *pathname,conxt char *arg,…,char #const encp[]);
int execv(const char *pathname, char *const argv[]);
int execvp(const char *filename, char *const argv[]);
int execve(const char *pathname, char *const argv[],char *const envp[]);

          exec函数族的特点
       用于启动一个指定路径和文件名的进程。
       某进程一旦调用了exec类函数，正在执行的程序结束，系统把代码段换成新的程序的代码，原有的数据段和堆栈段也被放弃，新的数据段和堆栈段被分配，但是进程号被保留。
       结果为：系统认为正在执行的还是原来的进程，但是进程对应的程序被替换了。

       子进程可以通过调用execve()函数来载入和运行另一个程序,这时子进程的Text,Data,Heap,Stack将被新程序对应的东西替换

        C library里面有一些exec开头的函数作用是差不多的

fork和exec搭配实现让父进程的代码执行又启动一个新的指定的进程。

execl()使用范例:

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

 main()
 {
    pid_t pid;
    printf("Now only one process\n");
    printf("Calling fork...\n");
    pid=fork();
    if(pid==0)    /*进程为子进程*/
    {
         printf("I am the child\n");
         execl("/bin/ls","-l",NULL);/*如果execl返回,说明调用失败*/
     perror("execl failed to run ls");
         exit(1);
     } else if(pid>0) /*进程为父进程*/
     {
          printf("I'm the parent, my child's pid is %d\n",pid);
          execl("/bin/ps","-c",NULL);
           /*如果execl返回,说明调用失败*/
         perror("execl failed to run ls");
          exit(1);
     } else {
          printf("Fork fall!\n");
     }

 }

3. 进程的终止和终止状态

1）.自杀：调用_exit()(或者相关的library中的exit()函数)

2）.他杀：给进程传送某种signal

_exit()可以指定终结的状态(终结的状态通常就是一个很小的整数)

通过某种signal终结进程，终结的状态根据signal的种类而不同

父进程通过wait()系统调用函数可以获取子进程终结后的终结状态

8. Linux进程调度

        UNIX 系统是单纯的分时系统，未设置高级调度——作业调度，只设置了中级调度——进程对换和低级调度——进程调度。 
1．引起进程调度的原因 
首先，由于 UNIX 系统是分时系统，因而其时钟中断处理程序须每隔一定时间便对要求进程调度程序进行调度的标志 runrun 予以置位，以引起调度程序重新调度。其次，当进
程执行了 wait、exit 及 sleep 等系统调用后要放弃处理机时，也会引起调度程序重新进行调度。此外，当进程执行完系统调用功能而从核心态返回到用户态时，如果系统中又出现了更高优先级的进程在等待处理机时，内核应抢占当前进程的处理机，这也会引起调度。  

2．调度算法 
采用动态优先数轮转调度算法进行进程调度。调度程序在进行调度时，首先从处于“内存就绪”或“被抢占”状态的进程中选择一个其优先数最小(优先级最高)的进程。若此时系统中(同时)有多个进程都具有相同的最高优先级，则内核将选择其中处于就绪状态或被抢占状态最久的进程，将它从其所在队列中移出，并进行进程上下文的切换，恢复其运行。 
3．进程优先级的分类 
UNIX 系统把进程的优先级分成两类，第一类是核心优先级，又可进一步把它分为可中断和不可中断两种。当一个软中断信号到达时，若有进程正在可中断优先级上睡眠，该进程将立即被唤醒；若有进程处于不可中断优先级上，则该进程继续睡眠。诸如“对换” 、 “等待磁盘I/O” 、 “等待缓冲区”等几个优先级，都属于不可中断优先级；而“等待输入” 、 “等待终端输出” 、 “等待子进程退出”几个优先级，都是可中断优先级。另一类是用户优先级，  它又被分成n+1级，其中第0级为最高优先级，第 n级的优先级最低。 

4．进程优先数的计算 
在进程调度算法中，非常重要的部分是如何计算进程的优先数。在系统Ⅴ中，进程优先数的计算公式可表示如下： 
优先数=   CPU的时间 最近使用/2    +基本用户优先数 

其中，基本用户优先数即 proc 结构中的偏移值 nice，可由用户将它设置成 0～40 中的任一个数。一旦设定后，用户仅能使其值增加，特权用户才有权减小 nice的值。而最近使用CPU的时间，则是指当前占有处理机的进程本次使用 CPU 的时间。内核每隔 16.667  ms 便对该时间做加 1 操作， 这样，占有 CPU 的进程其优先数将会随着它占有 CPU 时间的增加而加大，相应地，其优先级便随之降低。 

5．进程切换 
在OS中，凡要进行中断处理和执行系统调用时，都将涉及到进程上下文的保存和恢复问题，此时系统所保存或恢复的上下文都是属于同一个进程的。而在进程调度之后，内核所应执行的是进程上下文的切换，即内核是把当前进程的上下文保存起来，而所恢复的则是进程调度程序所选中的进程的上下文，以使该进程能恢复执行。  

8. Linux进程间通信

linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。而对Unix发展做出重大贡献的两大主力AT&T的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间通信方面的侧重点有所不同。前者对Unix早期的进程间通信手段进行了系统的改进和扩充，形成了“system V IPC”，通信进程局限在单个计算机内；后者则跳过了该限制，形成了基于套接口（socket）的进程间通信机制。Linux则把两者继承了下来，如图示：

   其中，

   1、最初Unix IPC包括：管道、FIFO、信号；

    2、System V IPC包括：System V消息队列、System V信号灯、System V共享内存区；

    3、Posix IPC包括：Posix消息队列、Posix信号灯、Posix共享内存区。

    有两点需要简单说明一下：

    1）由于Unix版本的多样性，电子电气工程协会（IEEE）开发了一个独立的Unix标准，这个新的ANSI Unix标准被称为计算机环境的可移植性操作系统界面（PSOIX）。现有大部分Unix和流行版本都是遵循POSIX标准的，而Linux从一开始就遵循POSIX标准；

    2）BSD并不是没有涉足单机内的进程间通信（socket本身就可以用于单机内的进程间通信）。事实上，很多Unix版本的单机IPC留有BSD的痕迹，如4.4BSD支持的匿名内存映射、4.3+BSD对可靠信号语义的实现等等。
      图一给出了linux 所支持的各种IPC手段，在本文接下来的讨论中，为了避免概念上的混淆，在尽可能少提及Unix的各个版本的情况下，所有问题的讨论最终都会归结到Linux环境下的进程间通信上来。并且，对于Linux所支持通信手段的不同实现版本（如对于共享内存来说，有Posix共享内存区以及System V共享内存区两个实现版本），将主要介绍Posix API。
linux下进程间通信的几种主要手段简介：
     管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
     信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）；
    报文（Message）队列（消息队列）：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
     共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
      信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。
      套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。