unix进程通信方式总结(中)（转）

在上一篇博客http://blog.csdn.net/caoyan_12727/article/details/52049417已经总结了<<uinx环境高级编程>>进程通信前四种方式：管道(pipe)，命名管道(FIFO)，消息队列，信号量，那么接下来让我们看看其他的四种重要的进程间通信方式：信号机制，共享存储。

(5)信号

　　　信号是一种软件中断(只是软件中断的一种)，中断就是操作系统遇到一些紧急需要处理的事情，停下当前正在处理的事情，转而去做另外一件事，这只是一个广义的理解。可以说计算机系统是以中断驱动的.为了让操作系统能够处理各种各样的中断，每一种中断都有其相应的编号，这个编号就叫中断向量(中断识别码)。一旦一个中断产生，操作系统就会根据中断向量去查询中断向量表，这个表里存放的是各种中断处理程序的入口地址，一旦找到相应的地址，操作系统就会执行相应的处理程序，然后从中断处理程序返回，执行之前被中断的程序。

　　　在信号产生时，可以告诉内核按以下三种方式进行处理，我们称之为信号处理或与信号相关的操作：

第一种：忽略此信号：大多数信号都采取这样的方式，但有两种信号决不能被忽略，它们是：SIGKILL和SIGSTOP，这两种信号不能被忽略的原因是它们向内核和超级用户提供了使进程终止或停止的方法。

第二种：捕捉此信号。为了做到这一点，要通知内核在某种信号发生时，调用一个用户函数。在用户函数中，可执行用户希望对这个时间进行的处理。

第三种：执行系统默认操作，执行该信号的默认操作，一些默认操作如下：

如果想详细了解这些信号的作用，请参照《unix环境高级编程》一书的252-256页.unix系统最简单的接口是signal函数，其定义如下：

定义函数：void (*signal(int signum, void(* handler)(int)))(int);
函数说明：signal()会依参数signum 指定的信号编号来设置该信号的处理函数. 当指定的信号到达时就会跳转到参数handler 指定的函数执行. 如果参数handler 不是函数指针, 则必须是下列两个常数之一：
1、SIG_IGN 忽略参数signum 指定的信号.
2、SIG_DFL 将参数signum 指定的信号重设为核心预设的信号处理方式.

我们可以看到void(* handler)(int)中handler是一个指向具有int型参数无返回值函数指针，其中signal是一个函数，这个函数返回一个指针，这个指针指向一个具有int型参数返回值为空的函数。可以看到signal和handler一个是函数，一个是函数指针，它们的返回值或被指函数的返回的都是一个指向一个int型参数而无返回值的函数指针。

我们来看一个简单的程序：

#include "apue.h"
static void sig_usr(int); /* one handler for both signals */
int main(void){
if (signal(SIGUSR1, sig_usr) == SIG_ERR)err_sys("can't catch SIGUSR1");
if (signal(SIGUSR2, sig_usr) == SIG_ERR)err_sys("can't catch SIGUSR2");
for ( ; ; )pause();
}

static void sig_usr(int signo){ /* argument is signal number */
if (signo == SIGUSR1)printf("received SIGUSR1\n");
else if (signo == SIGUSR2)printf("received SIGUSR2\n");
else err_dump("received signal %d\n", signo);
}
从上面的代码可以看出，signal函数相当于向系统声明当捕捉到SIGUSR1和SIGUSR2的时候就调用sig_usr来处理；
另一个和信号关联的就是可重入函数，一个函数的可重入就是表示这个函数还没有执行完，由于外部因素或内部调用又一次进入该函数执行时不会出现什么错误，一个函数能被重入可能有一下情况:

(i)多个线程同时执行这个函数(线程安全).

(ii)函数自身(可能是经过多层调用之后)调用自身；

(iii)进程执行到某个函数时，捕捉到一个信号，执行该信号的处理程序，然后从处理程序返回继续执行；

一个函数要成为可重入的，必须具备一下几点：

如何写出可重入的函数？在函数体内不访问那些全局变量，不使用静态局部变量，坚持只使用缺省态（auto）局部变量，写出的函数就将是可重入的。如果必须访问全局变量，记住利用互斥信号量来保护全局变量。或者调用该函数前关中断，调用后再开中断。可重入函数可以被一个以上的任务调用，而不必担心数据被破坏。可重入函数任何时候都可以被中断，一段时间以后又可以运行，而相应的数据不会丢失。可重入函数或者只使用局部变量，即保存在CPU寄存器中或堆栈中；或者使用全局变量，则要对全局变量予以保护。可参照博客http://www.bubuko.com/infodetail-312842.html。

下面我们就用一个简单的程序来说明进程间用信号来通信的方式：

#include "apue.h"
#include <sys/wait.h>
static void sig_cld(int);
int main(){
pid_t pid;
if (signal(SIGCLD, sig_cld) == SIG_ERR)perror("signal error");
if ((pid = fork()) < 0) {perror("fork error");
} else if (pid == 0) { /* child */
sleep(2);
_exit(0);
}
pause(); /* parent */
exit(0);
}
static void sig_cld(int signo){ /* interrupts pause() */
pid_t pid;
int status;
printf("SIGCLD received\n");
if (signal(SIGCLD, sig_cld) == SIG_ERR) /* reestablish handler */
perror("signal error");
if ((pid = wait(&status)) < 0) /* fetch child status */
perror("wait error");
printf("pid = %d\n", pid);
}
在上面的例子中，子进程被执行的时候就会因为sleep(2)被挂起，然而父进程会会因为pause()而进入睡眠状态从而被挂起。一旦子进程的计时器到时，就会产生一个子进程状态改变的信号，这个信号被递送给父进程，父进程会执行相关的处理程序(调用wait函数获取结束子进程的进程号)。对信号处理程序的重置是为了防止SIGCLD这个信号会被重置为默认值而丢失。
一个进程还可以通过kill函数来将信号发送到指定进程：int kill(pid_t pid, int sig);
函数说明：kill()可以用来送参数sig 指定的信号给参数pid 指定的进程。参数pid 有几种情况：
1、pid>0 将信号传给进程识别码为pid 的进程.
2、pid=0 将信号传给和目前进程相同进程组的所有进程
3、pid=-1 将信号广播传送给系统内所有的进程
4、pid<0 将信号传给进程组识别码为pid 绝对值的所有进程参数 sig 代表的信号编号可参考附录D
返回值：执行成功则返回0, 如果有错误则返回-1.
错误代码：
1、EINVAL 参数sig 不合法
2、ESRCH 参数pid 所指定的进程或进程组不存在
3、EPERM 权限不够无法传送信号给指定进程
(6)共享存储

共享存储允许两个或多个进程共享一个给定的存储区。这个时候数据就不需要在客户进程和服务进程之间复制，所以这是最快的一种IPC。使用共享村粗时需要掌握的唯一诀窍是，在多个进程之间同步访问一个给定的存储区.若服务器进程正在将数据放入共享存储区，则在它做完这易操作之前，客户进程不应该去取这些数据。以下是有关内存共享的重要的函数：

1.shmget函数

shmget(得到一个共享内存标识符或创建一个共享内存对象)
所需头文件 #include <sys/ipc.h>
#include <sys/shm.h>
函数说明 得到一个共享内存标识符或创建一个共享内存对象并返回共享内存标识符
函数原型 int shmget(key_t key, size_t size, int shmflg)
函数传入值 key 0(IPC_PRIVATE)：会建立新共享内存对象
大于0的32位整数：视参数shmflg来确定操作。通常要求此值来源于ftok返回的IPC键值
size 大于0的整数：新建的共享内存大小，以字节为单位
0：只获取共享内存时指定为0
shmflg 0：取共享内存标识符，若不存在则函数会报错
IPC_CREAT：当shmflg&IPC_CREAT为真时，如果内核中不存在键值与key相等的共享内存，则新建一个共享内存；如果存在这样的共享内存，返回此共享内存的标识符
IPC_CREAT|IPC_EXCL：如果内核中不存在键值与key相等的共享内存，则新建一个消息队列；如果存在这样的共享内存则报错
函数返回值 成功：返回共享内存的标识符
出错：-1，错误原因存于error中
附加说明 上述shmflg参数为模式标志参数，使用时需要与IPC对象存取权限（如0600）进行|运算来确定信号量集的存取权限
错误代码 EINVAL：参数size小于SHMMIN或大于SHMMAX
EEXIST：预建立key所指的共享内存，但已经存在
EIDRM：参数key所指的共享内存已经删除
ENOSPC：超过了系统允许建立的共享内存的最大值(SHMALL)
ENOENT：参数key所指的共享内存不存在，而参数shmflg未设IPC_CREAT位
ENOENT：参数key所指的共享内存不存在，而参数shmflg未设IPC_CREAT位
EACCES：没有权限
ENOMEM：核心内存不足

2.shmat函数

shmat(把共享内存区对象映射到调用进程的地址空间)
所需头文件 #include <sys/types.h>
#include <sys/shm.h>
函数说明 连接共享内存标识符为shmid的共享内存，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问
函数原型 void *shmat(int shmid, const void *shmaddr, int shmflg)
函数传入值 msqid 共享内存标识符
shmaddr 指定共享内存出现在进程内存地址的什么位置，直接指定为NULL让内核自己决定一个合适的地址位置
shmflg SHM_RDONLY：为只读模式，其他为读写模式
函数返回值 成功：附加好的共享内存地址
出错：-1，错误原因存于error中
附加说明 fork后子进程继承已连接的共享内存地址。exec后该子进程与已连接的共享内存地址自动脱离(detach)。进程结束后，已连接的共享内存地址会自动脱离(detach)
错误代码 EACCES：无权限以指定方式连接共享内存
EINVAL：无效的参数shmid或shmaddr
ENOMEM：核心内存不足

3.shmdt函数

shmdt(断开共享内存连接，解除物理内存到当前进程地址空间的映射)
所需头文件 #include <sys/types.h>
#include <sys/shm.h>
函数说明 与shmat函数相反，是用来断开与共享内存附加点的地址，禁止本进程访问此片共享内存
函数原型 int shmdt(const void *shmaddr)
函数传入值 shmaddr：连接的共享内存的起始地址
函数返回值 成功：0
出错：-1，错误原因存于error中
附加说明 本函数调用并不删除所指定的共享内存区，而只是将先前用shmat函数连接（attach）好的共享内存脱离（detach）目前的进程
错误代码 EINVAL：无效的参数shmaddr
注意函数返回的类型为void*;
4.shmctl函数

shmctl(共享内存管理)
所需头文件 #include <sys/types.h>
#include <sys/shm.h>
函数说明 完成对共享内存的控制
函数原型 int shmctl(int shmid, int cmd, struct shmid_ds *buf)
函数传入值 msqid 共享内存标识符
cmd IPC_STAT：得到共享内存的状态，把共享内存的shmid_ds结构复制到buf中
IPC_SET：改变共享内存的状态，把buf所指的shmid_ds结构中的uid、gid、mode复制到共享内存的shmid_ds结构内
IPC_RMID：删除这片共享内存
buf 共享内存管理结构体。具体说明参见共享内存内核结构定义部分
函数返回值 成功：0
出错：-1，错误原因存于error中
错误代码 EACCESS：参数cmd为IPC_STAT，确无权限读取该共享内存
EFAULT：参数buf指向无效的内存地址
EIDRM：标识符为msqid的共享内存已被删除
EINVAL：无效的参数cmd或shmid
EPERM：参数cmd为IPC_SET或IPC_RMID，却无足够的权限执行
下面我们分两步来了解共享存储:
第一步：看看共享存储在进程空间的映射情况：

#include "apue.h"
#include <sys/shm.h>
#include<iostream>
#define ARRAY_SIZE 40000
#define MALLOC_SIZE 100000
#define SHM_SIZE 100000
#define SHM_MODE 0600 /* user read/write */
using namespace std;
char array[ARRAY_SIZE]; /* uninitialized data = bss */

int main(void){
int shmid;
char *ptr, *shmptr;
printf("array[] from %p to %p\n", (void *)&array[0],(void *)&array[ARRAY_SIZE]);
printf("stack around %p\n", (void *)&shmid);
if ((ptr = (char *)malloc(MALLOC_SIZE)) == NULL)printf("malloc error\n");
printf("malloced from %p to %p\n", (void *)ptr,(void *)ptr+MALLOC_SIZE);
if ((shmid = shmget(IPC_PRIVATE, SHM_SIZE, SHM_MODE)) < 0)printf("shmget error\n");
if ((shmptr = (char *)shmat(shmid, 0, 0)) == (void *)-1)printf("shmat error\n");
printf("shared memory attached from %p to %p\n", (void *)shmptr,(void *)shmptr+SHM_SIZE);
if (shmctl(shmid, IPC_RMID, 0) < 0)printf("shmctl error\n");
exit(0);
}
运行结果：

可以看出共享存储的100000字节被映射到了当前进程的0xb76c9000到0xb76e16a0之间。如果不同进程共享同一存储，则它被映射到这些进程中的不同地址空间，大小和100000相等。

第二步：父进程和子进程共享同一段内存区域：

#include "apue.h"
#include <sys/shm.h>
#include<iostream>
#define SIZE 1024

int main(){
int shmid ;
char *shmaddr ;
struct shmid_ds buf ;
int flag = 0 ;
int pid ;
shmid = shmget(IPC_PRIVATE, SIZE, IPC_CREAT|0600 ) ;//建立新的共享内存
if ( shmid < 0 ){
printf("get shm ipc_id error\n") ;
return -1 ;
}
if ((pid = fork())==0){/*child*/
shmaddr = (char *)shmat( shmid, NULL, 0 ) ;
if ( (int)shmaddr == -1 ){
perror("shmat addr error") ;
return -1 ;
}
strcpy( shmaddr, "Hi, I am child process!\n") ;//将数据写入到共享内存区域
shmdt( shmaddr );//解除共享内存到子进程地址空间的映射
return 0;
}
else if(pid>0){/*father*/
sleep(1) ;
flag = shmctl( shmid, IPC_STAT, &buf);//在父进程中获取共享内存的相关信息，大小，父子进程号等等....
if ( flag == -1 ){
perror("shmctl shm error") ;
return -1 ;
}
printf("shm_segsz =%d bytes\n", buf.shm_segsz );
printf("parent pid=%d, shm_cpid = %d \n", getpid(), buf.shm_cpid ) ;
printf("chlid pid=%d, shm_lpid = %d \n",pid , buf.shm_lpid ) ;
shmaddr = (char *)shmat(shmid, NULL, 0 ) ;
if ( (int)shmaddr == -1 ){
perror("shmat addr error") ;
return -1 ;
}
printf("father process reading data from shared memmory: ");
printf("%s", shmaddr) ;
shmdt( shmaddr ) ;
shmctl(shmid, IPC_RMID, NULL) ;
}else{
perror("fork error") ;
shmctl(shmid, IPC_RMID, NULL) ;
}
return 0 ;
}
测试结果：

从上面的两个测试我们可以看出，共享内存(这里的内存指的是物理内存)其实是将物理内存的一片区域映射到进程的地址空间，真实的数据并不在进程的地址空间上。映射可以获得一个在当前进程空间的地址，进程对自己地址空间的操作(比如上面的strcpy)其实都是对共享内存区域的操作。这就让进程不必关心这块内存区域到底在哪里，只需对shmat返回的地址进行操作即可！！！！！这里要区别mmap函数，mmap函数将文件映射进自己的虚拟进程空间！！！！！
————————————————
版权声明：本文为CSDN博主「caoyan_12727」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/caoyan_12727/article/details/52126405