Linux之进程通信20160720

好久没更新了，今天主要说一下Linux的进程通信，后续Linux方面的更新应该会变缓，因为最近在看Java和安卓方面的知识，后续会根据学习成果不断分享更新Java和安卓的方面的知识~

Linux进程通信的知识，建议参照《UNIX环境高级编程》这本书，这里也只是做一个总结：

一.线程：进程中的子线程之间的通信，线程之间的内存（变量）是共享的，通过共享内存也就是全局变量即可，注意互斥即可

二.进程：进程之间的通信必须要借助内核实现：

1、pipe:

（无名）管道，只能用于父子进程间通信：单向的（一端写入一端读出），fork出来的就是子进程，对应的操作fock为父进程

创建管道的数组是两个大小，一个用于写同时关闭读的，一个用于读同时关闭写，两个整数一个给写的用，一个给读的用

示例代码：

无名管道由pipe（）函数创建：

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

}

}

2、named pipe：

（有名）管道：适用于无亲缘关系的进程，需要创建FIFO文件（有名字的文件，用于通信的文件）

在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、消息队列：

消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，是一个在系统内核中用来保存消息的队列，它在系统内核中是以消息链表的形式出现。消息链表中节点的结构用msg声明。

事实上，它是一种正逐渐被淘汰的通信方式，可以用流管道或者套接口的方式来取代它，所以，对此方式也不再解释，也建议读者忽略这种方式。

4、信号量：

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

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

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

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

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

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

struct sem {

short sempid;/* pid of last operaton */

ushort semval;/* current value */

ushort semncnt;/* num procs awaiting increase in semval */

ushort semzcnt;/* num procs awaiting semval = 0 */

}

　　 #include <sys/types.h>

　　 #include <sys/ipc.h>

　　 #include <sys/sem.h>

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

　  key是前面讲过的IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。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);

}

5、共享内存：效率高，注意互斥的问题（可以使用信号量来实现互斥，或者使用锁）

主要使用共享内存，效率高，A把数据放入内核某一个内存（共享内存），B直接去读就可以了

在Linux系统下，常用的方式是通过shmXXX函数族来实现利 用共享内存进行存储的。

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

　　　　 #include <sys/types.h>

　　　　 #include <sys/ipc.h>

　　　　 #include <sys/shm.h>

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

当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。

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

　　 shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。

三种比较类似：

创建/获得:（A创建   B获得）使用函数（消息队列：msgget），（信号量：semget），（共享内存：shmget），参数不同分为创建/获得

写：msgsnd ,semop,

读：msgrcv,semop

上述五种方式都是指同一台机子

6、网络通信，适用于不同机子，和相同机子(比如A进程向B进程发，不到硬件底层就到B了,速度也很快)都可以

移植性好，基本都支持，所以没有特殊要求比如要求速率非常高或者是父子进程的情况，一般就使用网络通信

见之前的文章SOCKET套接字编程有详细的说明

网络通信用的最多

特别的，

对于进程间传递描述符(实际比较少用到)

每个进程都拥有自己独立的进程空间，这使得描述符在进程之间的传递变得有点复杂，这个属于高级进程间通信的内容，下面就来说说。

Linux 下的描述符传递   Linux 系统系下，子进程会自动继承父进程已打开的描述符，实际应用中，可能父进程需要向子进程传递“后打开的描述符”，或者子进程需要向父进程传递；或者两个进程可能是无关的，显然这需要一套传递机制。

简单的说，首先需要在这两个进程之间建立一个 Unix 域套接字接口作为消息传递的通道（ Linux 系统上使用 socketpair 函数可以很方面便的建立起传递通道），然后发送进程调用 sendmsg 向通道发送一个特殊的消息，内核将对这个消息做特殊处理，从而将打开的描述符传递到接收进程。   然后接收方调用 recvmsg 从通道接收消息，从而得到打开的描述符。然而实际操作起来并不像看起来那样单纯。

先来看几个注意点：

1) 需要注意的是传递描述符并不是传递一个 int 型的描述符编号，而是在接收进程中创建一个新的描述符，并且在内核的文件表中，它与发送进程发送的描述符指向相同的项。

2) 在进程之间可以传递任意类型的描述符，比如可以是 pipe ， open ， mkfifo 或 socket ， accept 等函数返回的描述符，而不限于套接字。

3) 一个描述符在传递过程中（从调用 sendmsg 发送到调用 recvmsg 接收），内核会将其标记为“在飞行中”（ in flight ）。在这段时间内，即使发送方试图关闭该描述符，内核仍会为接收进程保持打开状态。发送描述符会使其引用计数加 1 。

4) 描述符是通过辅助数据发送的（结构体 msghdr 的 msg_control 成员），在发送和接收描述符时，总是发送至少 1 个字节的数据，即使这个数据没有任何实际意义。否则当接收返回 0 时，接收方将不能区分这意味着“没有数据”（但辅助数据可能有套接字）还是“文件结束符”。

5) 具体实现时， msghdr 的 msg_control 缓冲区必须与 cmghdr 结构对齐，可以看到后面代码的实现使用了一个 union 结构来保证这一点。

msghdr 和 cmsghdr 结构体

上面说过，描述符是通过结构体 msghdr 的 msg_control 成员送的，因此在继续向下进行之前，有必要了解一下 msghdr 和 cmsghdr 结构体，先来看看 msghdr 。

struct msghdr

{

void       *msg_name;

socklen_t    msg_namelen;

struct iovec  *msg_iov;

size_t       msg_iovlen;

void       *msg_control;

size_t       msg_controllen;

int          msg_flags;   };

sendmsg 和 recvmsg  函数原型如下：

#include <sys/types.h>

#include <sys/socket.h>

int sendmsg(int s, const struct msghdr *msg, unsigned int flags);

int recvmsg(int s, struct msghdr *msg, unsigned int flags);

二者的参数说明如下：

s，套接字通道，对于 sendmsg 是发送套接字，对于 recvmsg 则对应于接收套接字；

msg ，信息头结构指针；

flags ，可选的标记位，这与 send 或是 sendto 函数调用的标记相同。

7、信号，主要是通过kill来发送，但要知道对方的PID，所以事先可以先约定好，ID放到哪个文件，然后对方去读

详细机制介绍：

1） 信号本质

软中断信号（signal，又简称为信号）用来通知进程发生了异步事件。在软件层次上是对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是进程间通信机制中唯一的异步通信机制，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。信号机制除了基本通知功能外，还可以传递附加信息。

收到信号的进程对各种信号有不同的处理方法。处理方法可以分为三类：

第一种是类似中断的处理程序，对于需要处理的信号，进程可以指定处理函数，由该函数来处理。

第二种方法是，忽略某个信号，对该信号不做任何处理，就象未发生过一样。

第三种方法是，对该信号的处理保留系统的默认值，这种缺省操作，对大部分的信号的缺省操作是使得进程终止。进程通过系统调用signal来指定进程对某个信号的处理行为。

2） 信号的种类

可以从两个不同的分类角度对信号进行分类：

可靠性方面：可靠信号与不可靠信号；

与时间的关系上：实时信号与非实时信号。

3） 信号处理流程

对于一个完整的信号生命周期(从信号发送到相应的处理函数执行完毕)来说，可以分为三个阶段：

信号诞生

信号在进程中注册

信号的执行和注销

3.1)信号诞生

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

这里按发出信号的原因简单分类，以了解各种信号：

（1） 与进程终止相关的信号。当进程退出，或者子进程终止时，发出这类信号。

（2） 与进程例外事件相关的信号。如进程越界，或企图写一个只读的内存区域（如程序正文区），或执行一个特权指令及其他各种硬件错误。

（3） 与在系统调用期间遇到不可恢复条件相关的信号。如执行系统调用exec时，原有资源已经释放，而目前系统资源又已经耗尽。

（4） 与执行系统调用时遇到非预测错误条件相关的信号。如执行一个并不存在的系统调用。

（5） 在用户态下的进程发出的信号。如进程调用系统调用kill向其他进程发送信号。

（6） 与终端交互相关的信号。如用户关闭一个终端，或按下break键等情况。

（7） 跟踪进程执行的信号。

Linux支持的信号列表如下。很多信号是与机器的体系结构相关的

信号值 默认处理动作 发出信号的原因

SIGHUP 1 A 终端挂起或者控制进程终止

SIGINT 2 A 键盘中断（如break键被按下）

SIGQUIT 3 C 键盘的退出键被按下

SIGILL 4 C 非法指令

SIGABRT 6 C 由abort(3)发出的退出指令

SIGFPE 8 C 浮点异常

SIGKILL 9 AEF Kill信号

SIGSEGV 11 C 无效的内存引用

SIGPIPE 13 A 管道破裂: 写一个没有读端口的管道

SIGALRM 14 A 由alarm(2)发出的信号

SIGTERM 15 A 终止信号

SIGUSR1 30,10,16 A 用户自定义信号1

SIGUSR2 31,12,17 A 用户自定义信号2

SIGCHLD 20,17,18 B 子进程结束信号

SIGCONT 19,18,25 进程继续（曾被停止的进程）

SIGSTOP 17,19,23 DEF 终止进程

SIGTSTP 18,20,24 D 控制终端（tty）上按下停止键

SIGTTIN 21,21,26 D 后台进程企图从控制终端读

SIGTTOU 22,22,27 D 后台进程企图从控制终端写

处理动作一项中的字母含义如下

A 缺省的动作是终止进程

B 缺省的动作是忽略此信号，将该信号丢弃，不做处理

C 缺省的动作是终止进程并进行内核映像转储（dump core），内核映像转储是指将进程数据在内存的映像和进程在内核结构中的部分内容以一定格式转储到文件系统，并且进程退出执行，这样做的好处是为程序员提供了方便，使得他们可以得到进程当时执行时的数据值，允许他们确定转储的原因，并且可以调试他们的程序。

D 缺省的动作是停止进程，进入停止状况以后还能重新进行下去，一般是在调试的过程中（例如ptrace系统调用）

E 信号不能被捕获

F 信号不能被忽略

4) 信号的安装

如果进程要处理某一信号，那么就要在进程中安装该信号。安装信号主要用来确定信号值及进程针对该信号值的动作之间的映射关系，即进程将要处理哪个信号；该信号被传递给进程时，将执行何种操作。

linux主要有两个函数实现信号的安装：signal()、sigaction()。其中signal()只有两个参数，不支持信号传递信息，主要是用于前32种非实时信号的安装；而sigaction()是较新的函数（由两个系统调用实现：sys_signal以及sys_rt_sigaction），有三个参数，支持信号传递信息，主要用来与 sigqueue() 系统调用配合使用，当然，sigaction()同样支持非实时信号的安装。sigaction()优于signal()主要体现在支持信号带有参数。

4.1) signal()

#include <signal.h>

void (*signal(int signum, void (*handler))(int)))(int);

如果该函数原型不容易理解的话，可以参考下面的分解方式来理解：

typedef void (*sighandler_t)(int)；

sighandler_t signal(int signum, sighandler_t handler));

第一个参数指定信号的值，第二个参数指定针对前面信号值的处理，可以忽略该信号（参数设为SIG_IGN）；可以采用系统默认方式处理信号(参数设为SIG_DFL)；也可以自己实现处理方式(参数指定一个函数地址)。

如果signal()调用成功，返回最后一次为安装信号signum而调用signal()时的handler值；失败则返回SIG_ERR。

传递给信号处理例程的整数参数是信号值，这样可以使得一个信号处理例程处理多个信号。

static LD_VD SignalInit(LD_VD)

{

/* signal process */

//signal(SIGINT, SignalHnd);

//signal(SIGTERM, SignalHnd);

//一定要忽略这个信号，否则当服务器关闭tcp后，程序再往这个socket

//读写数据将导致程序直接退出

signal(SIGPIPE, SignalHnd);//使用了管道就安装对管道信号的处理

}

4.2) sigaction()

#include <signal.h>

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

5)       信号的发送

发送信号的主要函数有：kill()、raise()、 sigqueue()、alarm()、setitimer()以及abort()。

6)      信号集及信号集操作函数：

7)       信号阻塞与信号未决:

每个进程都有一个用来描述哪些信号递送到进程时将被阻塞的信号集，该信号集中的所有信号在递送到进程后都将被阻塞。下面是与信号阻塞相关的几个函数：

#include <signal.h>

int  sigprocmask(int  how,  const  sigset_t *set, sigset_t *oldset))；

int sigpending(sigset_t *set));

int sigsuspend(const sigset_t *mask))；

信号机制详细原文参考: http://www.cnblogs.com/hoys/archive/2012/08/19/2646377.html

8、流管道

该函数的原型是FILE * popen（const char* command, const char *type）;

command:使我们要执行的命令，即上述的运行命令，

type:有两种可能的取值，“r”（代表读取）或者“w"（代表写入）

popen（）会调用fork（）产生子进程，然后从子进程中调用/bin/sh-c来执行参数command的指令，参数type可使用“r”读取 或者“w”写入，根据type的值，popen（）会创建管道连接到子进程的标准输出设备或者标准输入设备，然后返回一个文件指针。随后进程就可以利用此文件指针来读取子进程的标准输出设备或者写入子进程的标准输入设备。

这个函数可以大大减少代码的编写量，但使用不太灵活，不能自己创建管道那么灵活，并且popen()必须使用标准的I/o函数进行操作，也不能使用read(),wirte()这种不带缓冲的I/O函数，必须使用pclose()来关闭管道流，该函数关闭标准I/O流，并等待命令执行结束

总结：向这个流中写内容相当于写入该命令（或者是该程序）标准输入； 向这个流中读数据相当于读取该命令（或者是该程序）的标准输出.

读:

LD_S32 RunSysCmd2(LD_CS8 *pCmd, LD_S8 *pRslBuf, LD_S32 bufSz)

{

LD_S32 ret = LD_FAILURE;

FILE *pFd = popen(pCmd, "r");//创建一个流管道生成一个子进程用于执行命令

if(pFd)

{

memset(pRslBuf, 0, bufSz);

if(fread(pRslBuf, bufSz - 1, 1, pFd) >= 0)//从该命令中读取数据

{

ret = LD_SUCCESS;

}

pclose(pFd);//关闭流管道

}

return ret;

}

写：

popen,system和exec区别:

1）.

system和popen都是执行了类似的运行流程，大致是fork->execl->return。但是我们看到system在执行期间调用进程会一直等待shell命令执行完成(waitpid等待子进程结束)才返回，但是popen无须等待shell命令执行完成就返回了。我们可以理解system为串行执行，在执行期间调用进程放弃了”控制权”，popen为并行执行。

popen中的子进程没人给它”收尸”了啊？是的，如果你没有在调用popen后调用pclose那么这个子进程就可能变成”僵尸”。

2）.

对于管道已经很清楚，而管道写可能用的地方比较少。而对于写可能更常用的是system函数：

system("cat "Read pipe successfully!" > test1")

可以看出，popen可以控制程序的输入或者输出，而system的功能明显要弱一点，比如无法将读取结果用于程序中。

如果不需要使用到程序的I/O数据流，那么system是最方便的。而且system函数是C89和C99中标准定义的，可以跨平台使用。而popen是Posix 标准函数，可能在某些平台无法使用（windows应该是可以的吧，没做过测试）。

如果上述两个函数还无法满足你的交互需求，那么可以考虑exec函数组了。

3）.

system是用shell来调用程序=fork+exec+waitpid，而exec是直接让你的程序代替用来的程序运行。

system 是在单独的进程中执行命令，完了还会回到你的程序中。而exec函数是直接在你的进程中执行新的程序，新的程序会把你的程序覆盖，除非调用出错，否则你再也回不到exec后面的代码，就是说你的程序就变成了exec调用的那个程序了。