Linux之进程通讯20160720

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

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

 

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

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

一、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);

}

}

二、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);

}

三、消息队列：

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

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

四、信号量：

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

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

}

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

主要使用共享内存，效率高，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

 

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

 

六、网络通讯，适用于不一样机子，和相同机子(好比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 函数调用的标记相同。

七、信号，主要是经过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

 

八、流管道

该函数的原型是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调用的那个程序了。