进程间通信：

一、管道（pipe）及有名管道（named pipe）

管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。

实现机制：

管道是由内核管理的一个缓冲区，相当于我们放入内存中的一个纸条。管道的一端连接一个进程的输出。这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。一个缓冲区不需要很大，它被设计成为环形的数据结构，以便管道可以被循环利用。当管道中没有信息的话，从管道中读取的进程会等待，直到另一端的进程放入信息。当管道被放满信息的时候，尝试放入信息的进程会等待，直到另一端的进程取出信息。当两个进程都终结的时候，管道也自动消失。

从原理上，管道利用fork机制建立，从而让两个进程可以连接到同一个PIPE上。最开始的时候，上面的两个箭头都连接在同一个进程Process 1上(连接在Process 1上的两个箭头)。当fork复制进程的时候，会将这两个连接也复制到新的进程(Process 2)。随后，每个进程关闭自己不需要的一个连接

实现细节：

在 Linux 中，管道的实现并没有使用专门的数据结构，而是借助了文件系统的file结构和VFS的索引节点inode。通过将两个 file 结构指向同一个临时的 VFS 索引节点，而这个 VFS 索引节点又指向一个物理页面而实现的。

关于管道的读写

 管道实现的源代码在fs/pipe.c中，在pipe.c中有很多函数，其中有两个函数比较重要，即管道读函数pipe_read()和管道写函数pipe_wrtie()。管道写函数通过将字节复制到 VFS 索引节点指向的物理内存而写入数据，而管道读函数则通过复制物理内存中的字节而读出数据。当然，内核必须利用一定的机制同步对管道的访问，为此，内核使用了锁、等待队列和信号。

当写进程向管道中写入时，它利用标准的库函数write()，系统根据库函数传递的文件描述符，可找到该文件的 file结构。file 结构中指定了用来进行写操作的函数（即写入函数）地址，于是，内核调用该函数完成写操作。写入函数在向内存中写入数据之前，必须首先检查 VFS 索引节点中的信息，同时满足如下条件时，才能进行实际的内存复制工作：内存中有足够的空间可容纳所有要写入的数据；内存没有被读程序锁定。

如果同时满足上述条件，写入函数首先锁定内存，然后从写进程的地址空间中复制数据到内存。否则，写入进程就休眠在 VFS 索引节点的等待队列中，接下来，内核将调用调度程序，而调度程序会选择其他进程运行。写入进程实际处于可中断的等待状态，当内存中有足够的空间可以容纳写入数据，或内存被解锁时，读取进程会唤醒写入进程，这时，写入进程将接收到信号。当数据写入内存之后，内存被解锁，而所有休眠在索引节点的读取进程会被唤醒。

管道的读取过程和写入过程类似。但是，进程可以在没有数据或内存被锁定时立即返回错误信息，而不是阻塞该进程，这依赖于文件或管道的打开模式。反之，进程可以休眠在索引节点的等待队列中等待写入进程写入数据。当所有的进程完成了管道操作之后，管道的索引节点被丢弃，而共享数据页也被释放。

Linux函数原型

#include <unistd.h>

int pipe(int filedes[2]);

创建的文件描述符会放到filedes中。之后就可以使用read与write文件操作函数进行操作管道了。

filedes[0]用于读出数据，读取时必须关闭写入端，即close(filedes[1]);

filedes[1]用于写入数据，写入时必须关闭读取端，即close(filedes[0])。

步骤：首先使用pipe创建管道，然后创建子进程，在父进程与子进程中各关闭一个对应的文件描述符。之后利用各自剩余的文件描述符操作即可。

命名管道(named PIPE)

由于基于fork机制，所以管道只能用于父进程和子进程之间，或者拥有相同祖先的两个子进程之间 (有亲缘关系的进程之间)。为了解决这一问题，Linux提供了FIFO方式连接进程。FIFO又叫做命名管道(named PIPE)。

FIFO (First in, Firstout)为一种特殊的文件类型，它在文件系统中有对应的路径。当一个进程以读(r)的方式打开该文件，而另一个进程以写(w)的方式打开该文件，那么内核就会在这两个进程之间建立管道，所以FIFO实际上也由内核管理，不与硬盘打交道。之所以叫FIFO，是因为管道本质上是一个先进先出的队列数据结构，最早放入的数据被最先读出来，从而保证信息交流的顺序。FIFO只是借用了文件系统(file system,命名管道是一种特殊类型的文件，因为Linux中所有事物都是文件，它在文件系统中以文件名的形式存在。)来为管道命名。写模式的进程向FIFO文件中写入，而读模式的进程从FIFO文件中读出。当删除FIFO文件时，管道连接也随之消失。FIFO的好处在于我们可以通过文件的路径来识别管道，从而让没有亲缘关系的进程之间建立连接

函数原型：

#include <sys/types.h>

#include <sys/stat.h> 

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

先用mkfifo创建一个命名管道，其实似乎相当于创建一个实实在在的文件，然后打开该文件，会得到文件描述符，然后在操作即可。

步骤:首先调用mkfifo创建有名管道，然后利用open打开该有名管道，之后操作即可。

二、信号（signal）

信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致的。

信号种类

当信号发生的时候，可以有三种选择（称之为Disposition of the signal或者Action associated with a signal）

1).忽略信号。大部分信号都可以Ignore，除了SIGKILL和SIGSTOP，这是为了提供一个确定的方法来Stop或者Kill一个Process。此外，如果我们忽略部分硬件异常产生的信号，进程的行为未定义。

2).捕捉信号。可以让内核来调用我们所指定的函数。SIGKILL和SIGSTOP无法捕捉。

3).执行缺省行为。如果不做任何处理，则执行缺省动作。大部分信号的缺省行为都是中止进程。

信号本质

信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。

信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后，功能更加强大，除了基本通知功能外，还可以传递附加信息。
信号来源

信号事件的发生有两个来源：硬件来源(比如我们按下了键盘或者其它硬件故障)；软件来源，最常用发送信号的系统函数是kill, raise, alarm和setitimer以及sigqueue函数，软件来源还包括一些非法运算等操作。

关于信号处理机制的原理(内核角度)

内核给一个进程发送软中断信号的方法，是在进程所在的进程表项的信号域设置对应于该信号的位。这里要补充的是，如果信号发送给一个正在睡眠的进程，那么要看该进程进入睡眠的优先级，如果进程睡眠在可被中断的优先级上，则唤醒进程；否则仅设置进程表中信号域相应的位，而不唤醒进程。这一点比较重要，因为进程检查是否收到信号的时机是：一个进程在即将从内核态返回到用户态时；或者，在一个进程要进入或离开一个适当的低调度优先级睡眠状态时。    

内核处理一个进程收到的信号的时机是在一个进程从内核态返回用户态时。所以，当一个进程在内核态下运行时，软中断信号并不立即起作用，要等到将返回用户态时才处理。进程只有处理完信号才会返回用户态，进程在用户态下不会有未处理完的信号。    

内核处理一个进程收到的软中断信号是在该进程的上下文中，因此，进程必须处于运行状态。如果进程收到一个要捕捉的信号，那么进程从内核态返回用户态时执行用户定义的函数。而且执行用户定义的函数的方法很巧妙，内核是在用户栈上创建一个新的层，该层中将返回地址的值设置成用户定义的处理函数的地址，这样进程从内核返回弹出栈顶时就返回到用户定义的函数处，从函数返回再弹出栈顶时，才返回原先进入内核的地方，接着原来的地方继续运行。这样做的原因是用户定义的处理函数不能且不允许在内核态下执行（如果用户定义的函数在内核态下运行的话，用户就可以获得任何权限）。

（从内核态回到用户态之前，会先处理PCB中记录的信号 ,发现有一个 SIGINT 信号待处理,而这个信号的默认处理动作是终止进程，所以直接终止进程而不再返回它的用户空间代码执行。）

内核实现信号捕捉的步骤：

1、用户为某信号注册一个信号处理函数sighandler。

2、当前正在执行主程序，这时候因为中断、异常或系统调用进入内核态。

3、在处理完异常要返回用户态的主程序之前，检查到有信号未处理，并发现该信号需要按照用户自定义的函数来处理。

4、内核决定返回用户态执行sighandler函数，而不是恢复main函数的上下文继续执行！（sighandler和main函数使用的是不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程）

5、sighandler函数返回后，执行特殊的系统调用sigreturn从用户态回到内核态

6、检查是否还有其它信号需要递达，如果没有 则返回用户态并恢复主程序的上下文信息继续执行。

#include <signal.h>

void (*signal(int signo, void (*func)(int)))(int)

//成功返回前一个信号布署，错误返回SIG_ERR。

1、使用typedef拆解

typedef void(*sighandler_t)(int);

sighandler_t signal(intsignum,sighandler_t handler);

2、使用函数指针理解

int (*p)();

p指向的是一个不带任何参数，并且返回值为int的函数；

int (*fun())();

这个式子与上式区别在于用fun()代替p，即fun()返回值是一个函数指针，这个函数指针(可以看作p)，指向一个不带任何参数，并且返回值为int的函数；因此，对于

void (*signal(intsigno,void(*func)(int)))(int);

可以看成是signal()函数，此函数带两个参数：一个为整型，一个为函数指针。而这个signal()函数的返回值也为一个函数指针，这个函数指针指向一个带一个整型参数，并且返回值为void的函数。

这个函数过于复杂，本身没有任何意义，通常都是使用typedef之后的简单信号处理函数。

kill和raise函数

kill函数将信号发送给进程或进程组。raise函数则允许进程向自身发送信号。

#include <signal.h>

int kill(pid_t pid, int signo);

int raise(int signo);

//两者成功都返回0，错误返回-1

调用raise(signo)等价于kill(getpid(),signo);

kill的pid参数有四种情况：

1).pid > 0，信号被发送给进程ID为pid的进程；

2).pid ＝＝ 0，信号被发送给与发送进程属于同一进程组的所有进程(这些进程的进程组ID等于发送进程的进程组ID)，而且发送进程具有向这些进程发送信号的权限。注意术语“所有进程”不包括实现定义的系统进程集。对于多数UNIX系统，这个系统进程集包括内核进程和init（pid 1）；

3).pid < 0，将该信号发送给ID等于pid的绝对值，且发送者对其有发送信号的权限的所有进程。如上，所有进程集不包括系统进程。

4).pid == -1，将该信号发送给发送进程有权限向它们发送喜好的系统上的所有进程。和前面一样，不包含特定的系统进程。

alarm和pause函数

1).使用alarm函数可以设置一个时间值(闹钟时间)，在将来的某个时刻该时间值会被超过。当所设置的时间值被超过后，产生SIGALRM信号。如果不忽略或不捕捉此信号，则其认动作是终止该进程。

#include <unistd.h> 

unsigned int alarm(unsigned int seconds);

//返回0或上次设置的警报到现在的时间。

如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它还没有超时，则该闹钟时间的余留值作为本次alarm函数调用的值返回。以前登记的闹钟时间则被新值代换。如果有以前登记的尚未超过的闹钟时间，而且seconds值是0，则取消以前的闹钟时间，其余留值仍作为函数的返回值。

2).pause函数使调用进程挂起直至捕捉到一个信号。

#include <unistd.h> 

int pause(void);

//返回-1，errno设置为EINTR。

只有执行了一个信号处理程序并从其返回时， pause才返回。在这种情况下， pause返回-1，errno设置为EINTR。

abort函数

abort函数的功能是使程序异常终止

#include <stdlib.h> 

void abort(void);

//函数决不返回。

此函数将SIGABRT信号发送给调用进程。进程不应忽略此信号。

system函数

System函数除了会执行可执行文件创建子进程之外，还会设置sigmask为忽略SIGINT，SIGQUIT并阻塞 SIGCHLD。

1). 忽略SIGINT和SIGQUIT的原因是，只有子进程应该处理这两个signal，而父进程无需处理

2). 阻塞SIGCHLD的原因是，System函数需要知道子进程的结束，而父进程不应该先提前知道，以免提前调用wait函数使得System函数本身无法获得进程的退出值

sleep函数

#include <unistd.h> 

unsigned int sleep(unsigned int seconds);

//返回0或未睡眠的秒数。

此函数使调用进程被挂起直到：
(1) 已经过了seconds所指定的墙上时钟时间；
(2) 该进程捕捉到一个信号并从信号处理程序返回。
如同alarm信号一样，由于某些系统活动，实际返回时间比所要求的会迟一些

实例分析

1、实例源代码
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
/*
* 自定义的信号处理函数
* */
void my_func(int sign_no)
{
    if(sign_no==SIGBUS)
    {
        printf("I have get SIGBUSn");
    }
}
/*
 * 程序入口
 * */
int main()
{
    printf("Waiting for signal SIGBUS n ");

    /*注册信号处理函数*/
    signal(SIGBUS,my_func);

    pause();//将进程挂起直到捕捉到信号为止
    exit(0);
}

三、消息队列（message）

系统V消息队列是随内核持续的，只有在内核重起或者显示删除一个消息队列时，该消息队列才会真正被删除。因此系统中记录消息队列的数据结构（struct ipc_ids msg_ids）位于内核中，系统中的所有消息队列都可以在结构msg_ids中找到访问入口。

消息队列就是一个消息的链表。每个消息队列都有一个队列头，用结构struct msg_queue来描述。队列头中包含了该消息队列的大量信息，包括消息队列键值、用户ID、组ID、消息队列中消息数目等等，甚至记录了最近对消息队列读写进程的ID。读者可以访问这些信息，也可以设置其中的某些信息。

下图说明了内核与消息队列是怎样建立起联系的： 
其中：struct ipc_ids msg_ids是内核中记录消息队列的全局数据结构；struct msg_queue是每个消息队列的队列头。

从上图可以看出，全局数据结构struct ipc_ids msg_ids可以访问到每个消息队列头的第一个成员：struct kern_ipc_perm；而每个struct kern_ipc_perm能够与具体的消息队列对应起来是因为在该结构中，有一个key_t类型成员key，而key则唯一确定一个消息队列。

1、标示符和键

每个内核中的IPC结构都用一个非负整数的标识符加以引用。标识符是IPC对象的内部名。为使多个合作进程能够在同一IPC对象上会合，需要提供一个外部命名方案。为此使用键与每个IPC对象关联。键的数据类型为key_t，由内核变换成标识符。

ftok提供的唯一服务是从一个路径名和工程ID产生一个关键字的一个方法。

#include <sys/ipc.h> 

key_t ftok(const char *path, int id);

//成功返回关键字，失败返回(key_t)-1。

path参数必须指向一个已有的文件。在产生关键字时只有id的低8位被使用。

2、打开或创建消息队列 

消息队列的内核持续性要求每个消息队列都在系统范围内对应唯一的键值，所以，要获得一个消息队列的描述字，只需提供该消息队列的键值即可；

通常第一个被调用的函数是msgget,其功能是打开一个现存队列或创建一个新队列

#include <sys/msg.h> 

int msgget (key_t key, int flag);

//成功返回消息队列ID。错误返回-1。

注：消息队列描述字是由在系统范围内唯一的键值生成的，而键值可以看作对应系统内的一条路经。

3、读写操作

消息读写操作非常简单，对开发人员来说，每个消息都类似如下的数据结构：

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

mtype成员代表消息类型，从消息队列中读取消息的一个重要依据就是消息的类型；mtext是消息内容，当然长度不一定为1。因此，对于发送消息来说，首先预置一个msgbuf缓冲区并写入消息类型和内容，调用相应的发送函数即可；对读取消息来说，首先分配这样一个msgbuf缓冲区，然后把消息读入该缓冲区即可。

调用msgsnd将数据放到消息队列上

#include <sys/msg.h> 

int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag);

//成功返回0，错误返回-1。

msgrcv从队列中取用消息

#include <sys/msg.h> 

ssize_t msgrcv(int msqid, void *ptr, size_t nbytes, long type, int flag);

//成功返回消息的数据部分的尺寸，错误返回-1。

int msgctl(intmsqid, int cmd, struct msqid_ds *buf); 
该系统调用对由msqid标识的消息队列执行cmd操作，共有三种cmd操作：IPC_STAT、IPC_SET 、IPC_RMID。IPC_STAT：该命令用来获取消息队列信息，返回的信息存贮在buf指向的msqid结构中；

IPC_SET：该命令用来设置消息队列的属性，要设置的属性存储在buf指向的msqid结构中；可设置属性包括：msg_perm.uid、msg_perm.gid、msg_perm.mode以及msg_qbytes，同时，也影响msg_ctime成员。

IPC_RMID：删除msqid标识的消息队列；

调用返回：成功返回0，否则返回-1。

步骤：首先调用msgget创建消息队列，在用msgsnd往消息队列中添加消息，用msgrcv接受消息队列中的数据。

消息队列与管道以及有名管道相比，具有更大的灵活性，首先，它提供有格式字节流，有利于减少开发人员的工作量；其次，消息具有类型，在实际应用中，可作为优先级使用。这两点是管道以及有名管道所不能比的。同样，消息队列可以在几个进程间复用，而不管这几个进程是否具有亲缘关系，这一点与 有名管道很相似；但消息队列是随内核持续的，与有名管道（随进程持续）相比，生命力更强，应用空间更大。

四、共享内存（shared memory）

可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等。

共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。共享内存往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。

1、调用的第一个函数通常是shmget，它获得一个共享存储标识符。

#include <sys/shm.h>

int shmget(key_t key, size_t size, int flag);

//成功返回共享内存ID，错误返回-1。

2、一旦创建了一个共享存储段，进程就可调用shmat将其连接到它的地址空间中。

#include <sys/shm.h> 

void *shmat(int shmid, const void *addr, int flag);

//成功返回共享内存段的指针，错误返回-1。

功能：用来创建或打开一个共享内存对象
原型 intshm_open(const char *name, int oflag, mode_t mode); 
参数
name:共享内存对象的名字，必须以/打头，并且后续不能有其它/ ，形如/somename长度不能超过NAME_MAX（255）
oflag:与open函数类似，可以是O_RDONLY、O_RDWR，还可以按位或上O_CREAT、O_EXCL、O_TRUNC等。
mode:此参数总是需要设置，如果oflag没有指定了O_CREAT，可以指定为0
返回值：成功返回非负整数文件描述符；失败返回-1

注意，不存在所谓的shm_close 函数，可以直接使用close 来关闭文件描述符。

当对共享存储段的操作已经结束时，则调用shmdt脱接该段。注意，这并不从系统中删除其标识符以及其数据结构。该标识符仍然存在，直至某个进程（一般是服务器）调用shmctl（带命令IPCRMID）特地删除它。

#include <sys/shm.h> 

int shmdt (void *addr);

//成功返回0，错误返回-1

步骤：首先用shmget创建共享内存，然后用shmat映射共享内存，用一个指针指向该共享内存即可对其进行操作。

共享内存允许两个或多个进程共享一给定的存储区，因为数据不需要来回复制，所以是最快的一种进程间通信机制。共享内存可以通过 mmap()映射普通文件（特殊情况下还可以采用匿名映射）机制实现，也可以通过系统V共享内存机制实现。应用接口和原理很简单，内部机制复杂。为了实现 更安全通信，往往还与信号灯等同步机制共同使用。

共享内存涉及到了存储管理以及文件系统等方面的知识，深入理解其内部机制有一定的难度，关键还要紧紧抓住内核使用的重要数据结构。系统 V共享内存是以文件的形式组织在特殊文件系统shm中的。通过shmget可以创建或获得共享内存的标识符。取得共享内存标识符后，要通过shmat将这 个内存区映射到本进程的虚拟地址空间。

五、信号量（semaphore）

主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。

信号量(semaphore)实际是一个整数，它的值由多个进程进行测试(test)和设置(set)。就每个进程所关心的测试和设置操作而言，这两个操作是不可中断的，或称“原子”操作，即一旦开始直到两个操作全部完成。测试和设置操作的结果是：信号量的当前值和设置值相加，其和或者是正或者为负。根据测试和设置操作的结果，一个进程可能必须睡眠，直到有另一个进程改变信号量的值。

信号量可用来实现所谓的“临界区”的互斥使用，临界区指同一时刻只能有一个进程执行其中代码的代码段。为了进一步理解信号量的使用，下面我们举例说明。

假设你有很多相互协作的进程，它们正在读或写一个数据文件中的记录。你可能希望严格协调对这个文件的存取，于是你使用初始值为1的信号量。当第一个进程存取文件时，它把信号量的值减1，并获得成功，信号量的值现在变为0，这个进程可以继续执行并存取数据文件。但是，如果另外一个进程也希望存取这个文件，那么它也把信号量的值减1，结果是不能存取这个文件，因为信号量的值变为-1。这个进程将被挂起，直到第一个进程完成对数据文件的存取。当第一个进程完成对数据文件的存取，它将增加信号量的值，使它重新变为1，现在，等待的进程被唤醒，它对信号量的减1操作将获得成功。

要调用的第一个函数是semget以获得一个信号量ID

#include <sys/sem.h> 

int semget(key_t key, int nsems, int flag);

//成功返回信号量ID。错误返回-1。

函数semop自动执行信号量集合上的操作数组。

#include <sys/sem.h> 

int semop(int semid, struct sembuf semoparray[], size_t nops);

//成功返回0，错误返回-1。

semoparray是一个指针，它指向一个信号量操作数组。

struct sembuf {

  unsigned short sem_num;/* member # in set (0, 1, ... nsems - 1) */

  short      sem_op;/* operation (negative, 0, or positive) */

  short      sem_flg;/*IPC_NOWAIT, SEM_UNDO */

};

semctl (得到一个信号量集标识符或创建一个信号量集对象) 

int semctl(int semid, int semnum, int cmd, union semun arg)

semid：信号量集标识符

semnum：信号量集数组上的下标，表示某一个信号量

arg：

union semun {

   short val;/*SETVAL用的值*/

   struct semid_ds* buf; /*IPC_STAT、IPC_SET用的semid_ds结构*/

   unsigned short* array; /*SETALL、GETALL用的数组值*/

   struct seminfo *buf;/*为控制IPC_INFO提供的缓存*/

  } arg; 

函数返回值

成功：大于或等于0，具体说明请参照表15-4 

出错：-1，错误原因存于error中

步骤：首先调用ftok获得键值，然后调用semget创建信号量集，利用semctl指明信号量对应的对象，使用对象时利用semop进行信号量的加减。

六、套接字（socket）

这是一种更为一般得进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。

参考了http://blog.csdn.net/hguisu/article/details/7445768/这篇博客，谢谢。

进程通信的概念最初来源于单机系统。由于每个进程都在自己的地址范围内运行，为保证两个相互通信的进程之间既互不干扰又协调一致工作，操作系统为进程通信提供了相应设施，如

UNIXBSD有：管道（pipe）、命名管道（namedpipe）软中断信号（signal）

UNIXsystem V有：消息（message）、共享存储区（sharedmemory）和信号量（semaphore)等。

他们都仅限于用在本机进程之间通信。网间进程通信要解决的是不同主机进程间的相互通信问题（可把同机进程通信看作是其中的特例）。为此，首先要解决的是网间进程标识问题。同一主机上，不同进程可用进程号（processID）唯一标识。但在网络环境下，各主机独立分配的进程号不能唯一标识该进程。例如，主机A赋于某进程号5，在B机中也可以存在5号进程，因此，“5号进程”这句话就没有意义了。 其次，操作系统支持的网络协议众多，不同协议的工作方式不同，地址格式也不同。因此，网间进程通信还要解决多重协议的识别问题。 

其实TCP/IP协议族已经帮我们解决了这个问题，网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。

使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是我为什么说“一切皆socket”。

1、 socket套接字：

      socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –>关闭close”模式来操作。Socket就是该模式的一个实现， socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）.
      说白了Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

       注意：其实socket也没有层的概念，它只是一个facade设计模式的应用，让编程变的更简单。是一个软件抽象层。在网络编程中，我们大量用的都是通过socket实现的。

2、套接字描述符

        其实就是一个整数，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr。

套接字API最初是作为UNIX操作系统的一部分而开发的，所以套接字API与系统的其他I/O设备集成在一起。特别是，当应用程序要为因特网通信而创建一个套接字（socket）时，操作系统就返回一个小整数作为描述符（descriptor）来标识这个套接字。然后，应用程序以该描述符作为传递参数，通过调用函数来完成某种操作（例如通过网络传送数据或接收输入的数据）。

在许多操作系统中，套接字描述符和其他I/O描述符是集成在一起的，所以应用程序可以对文件进行套接字I/O或I/O读/写操作。

当应用程序要创建一个套接字时，操作系统就返回一个小整数作为描述符，应用程序则使用这个描述符来引用该套接字需要I/O请求的应用程序请求操作系统打开一个文件。操作系统就创建一个文件描述符提供给应用程序访问文件。从应用程序的角度看，文件描述符是一个整数，应用程序可以用它来读写文件。下图显示，操作系统如何把文件描述符实现为一个指针数组，这些指针指向内部数据结构。

 对于每个程序系统都有一张单独的表。精确地讲，系统为每个运行的进程维护一张单独的文件描述符表。当进程打开一个文件时，系统把一个指向此文件内部数据结构的指针写入文件描述符表，并把该表的索引值返回给调用者 。应用程序只需记住这个描述符，并在以后操作该文件时使用它。操作系统把该描述符作为索引访问进程描述符表，通过指针找到保存该文件所有的信息的数据结构。

针对套接字的系统数据结构：

   1）、套接字API里有个函数socket，它就是用来创建一个套接字。套接字设计的总体思路是，单个系统调用就可以创建任何套接字，因为套接字是相当笼统的。一旦套接字创建后，应用程序还需要调用其他函数来指定具体细节。例如调用socket将创建一个新的描述符条目：

   2）、虽然套接字的内部数据结构包含很多字段，但是系统创建套接字后，大多数字字段没有填写。应用程序创建套接字后在该套接字可以使用之前，必须调用其他的过程来填充这些字段。

3、文件描述符和文件指针的区别：

文件描述符：在linux系统中打开文件就会获得文件描述符，它是个很小的正整数。每个进程在PCB（ProcessControl Block）中保存着一份文件描述符表，文件描述符就是这个表的索引，每个表项都有一个指向已打开文件的指针。

文件指针：C语言中使用文件指针做为I/O的句柄。文件指针指向进程用户区中的一个被称为FILE结构的数据结构。FILE结构包括一个缓冲区和一个文件描述符。而文件描述符是文件描述符表的一个索引，因此从某种意义上说文件指针就是句柄的句柄（在Windows系统上，文件描述符被称作文件句柄）。

详细内容请看linux文件系统：http://blog.csdn.net/hguisu/article/details/6122513#t7

在生活中，A要电话给B，A拨号，B听到电话铃声后提起电话，这时A和B就建立起了连接，A和B就可以讲话了。等交流结束，挂断电话结束此次交谈。  打电话很简单解释了这工作原理：“open—write/read—close”模式。

服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

这些接口的实现都是内核来完成。具体如何实现，可以看看linux的内核

4.1、socket()函数

int socket(int protofamily, int type, int protocol);//返回sockfd

sockfd是描述符。

socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket函数的三个参数分别为：

·protofamily：即协议域，又称为协议族（family）。常用的协议族有，AF_INET(IPV4)、AF_INET6(IPV6)、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。

·type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（socket的类型有哪些？）。

·protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议（这个协议我将会单独开篇讨论！）。

注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。

4.2、bind()函数

正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

函数的三个参数分别为：

·sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。

·addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是： 

·struct sockaddr_in {

·    sa_family_t sin_family; /* address family: AF_INET */

·    in_port_t  sin_port;  /* port in network byte order */

·    struct in_addr sin_addr; /* internet address */

·};       

·/* Internet address. */

·struct in_addr {

·    uint32_t s_addr; /* address in network byte order */

   };

ipv6对应的是： 

struct sockaddr_in6 { 

    sa_family_t sin6_family; /* AF_INET6 */ 

    in_port_t  sin6_port;  /* port number */ 

    uint32_t   sin6_flowinfo; /* IPv6 flow information */ 

    struct in6_addr sin6_addr; /* IPv6 address */ 

    uint32_t  sin6_scope_id; /* Scope ID (new in 2.4) */ 

}; 

struct in6_addr { 

    unsigned char s6_addr[16]; /* IPv6 address */ 

};

Unix域对应的是： 

#define UNIX_PATH_MAX  108

struct sockaddr_un { 

    sa_family_t sun_family; /* AF_UNIX */ 

    char sun_path[UNIX_PATH_MAX]; /* pathname */ 

};

· addrlen：对应的是地址的长度。

通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

网络字节序与主机字节序

主机字节序就是我们平常说的大端和小端模式：不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序，这个叫做主机序。引用标准的Big-Endian和Little-Endian的定义如下：

a)Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

b)Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

网络字节序：4个字节的32bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit。这种传输次序称作大端字节序。由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序，因此它又称作网络字节序。字节序，顾名思义字节的顺序，就是大于一个字节类型的数据在内存中的存放顺序，一个字节的数据没有顺序的问题了。

所以：在将一个地址绑定到socket的时候，请先将主机字节序转换成为网络字节序，而不要假定主机字节序跟网络字节序一样使用的是Big-Endian。由于这个问题曾引发过血案！公司项目代码中由于存在这个问题，导致了很多莫名其妙的问题，所以请谨记对主机字节序不要做任何假定，务必将其转化为网络字节序再赋给socket。

4.3、listen()、connect()函数

如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

int listen(int sockfd, int backlog);

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

4.4、accept()函数

TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就向TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); //返回连接connect_fd

参数sockfd

参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。

参数addr

这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。

参数len

如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。

如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字来完成与客户的通信。

注意：

      accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。

此时我们需要区分两种套接字，

       监听套接字: 监听套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，是服务器开始调用socket()函数生成的，称为监听socket描述字(监听套接字)

       连接套接字：一个套接字会从主动连接的套接字变身为一个监听套接字；而accept函数返回的是已连接socket描述字(一个连接套接字)，它代表着一个网络已经存在的点点连接。

       一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

       自然要问的是：为什么要有两种套接字？原因很简单，如果使用一个描述字的话，那么它的功能太多，使得使用很不直观，同时在内核确实产生了一个这样的新的描述字。

连接套接字socketfd_new 并没有占用新的端口与客户端通信，依然使用的是与监听套接字socketfd一样的端口号

4.5、read()、write()等函数

万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：

· read()/write()

· recv()/send()

· readv()/writev()

· recvmsg()/sendmsg()

· recvfrom()/sendto()

我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

ssize_t write(int fd, const void *buf, size_t count);

#include <sys/types.h>

#include <sys/socket.h>

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,

const struct sockaddr *dest_addr, socklen_t addrlen);

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,

         struct sockaddr *src_addr, socklen_t *addrlen); 

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);

ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。

write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1，并设置errno变量。在网络程序中，当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0，表示写了部分或者是全部的数据。2)返回的值小于0，此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接)。

4.6、close()函数

在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。

#include <unistd.h>

int close(int fd);

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

最后

以上就是复杂奇迹为你收集整理的linux进程间通讯一、管道（pipe）及有名管道（named pipe）二、信号（signal）三、消息队列（message）四、共享内存（shared memory）五、信号量（semaphore）六、套接字（socket）的全部内容，希望文章能够帮你解决linux进程间通讯一、管道（pipe）及有名管道（named pipe）二、信号（signal）三、消息队列（message）四、共享内存（shared memory）五、信号量（semaphore）六、套接字（socket）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。