Linux系统编程——进程间通信（System V IPC 对象）

基本查看命令

ipcs -m查看共享内存 ipcs -s查看信号量 ipcs -q查看消息队列

ipcrm -m id 删除共享内存 -M+key值

ipcrm -s id 删除信号量

ipcrm -q id 删除消息队列

(1)共享内存。为了在多个进程间进行信息交换，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。共享内存允许两个或者更多进程共享一给定的存储区，是一种效率最高的进程间通信方式，因为数据不需要再服务端和客户端之间进行复制，进程可以直接读写内存。

由于多个进程共享一段内存，因此也要依靠某种同步机制，如互斥锁和信号量等。第一个运行的进程创建共享内存，多个进程进行映射访问，最后一个访问的进程关闭共享内存。

两个不同进程A、B共享内存的意思是：同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。

#include <signal.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <errno.h>
#include <sys/shm.h>
typedef struct
{
pid_t pid;
char text[1024];
}SHM;
void func(int sig_no)
{

}
int main(int argc, const char *argv[])
{
int shmid;
SHM *p;
key_t key;
pid_t peerpid;
signal(SIGUSR1,func);
key = ftok(".",'s');
//shmget(,,0666);
//shmget(,,0666 | IPC_CREAT);
//shmget(,,0666 | IPC_CREAT | IPC_EXCL);
if((shmid = shmget(key,2048,IPC_CREAT | 0666 | IPC_EXCL)) < 0)
{
if(errno == EEXIST)
{
shmid = shmget(key,2048,0666);
if((p =(SHM *)shmat(shmid,NULL,0)) < (SHM *)0)
{
perror("fail to shmat");
return -1;
}
peerpid = p -> pid;
p->pid = getpid();
kill(peerpid,SIGUSR1);
}
else
{
perror("fail to shmget");
return -1;
}
}
else
{
if((p =(SHM *)shmat(shmid,NULL,0)) < (SHM *)0)
{
perror("fail to shmat");
return -1;
}
p->pid = getpid();
pause();
peerpid = p -> pid;
}

/**********************write.c***************************/
while(1)
{
fgets(p->text,1024,stdin);
kill(peerpid,SIGUSR1);
if(strncmp(p->text,"quit",4) == 0)break;
pause();
}
/*************************read.c************************/
while(1)
{
pause();
printf("read from shm:%s",p->text);
if(strncmp(p->text,"quit",4) == 0) break;
kill(peerpid,SIGUSR1);
}
/*************************************************/
if(shmdt(p) < 0)
{
perror("fail to shmdt");
return -1;
}
if(shmctl(shmid,IPC_RMID,NULL) < 0)
{
perror("fail to shmctl");
return -1;
}
return 0;

共享内存的使用步骤：


采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。

(2)消息队列。消息队列是一个消息的列表，存放在内核中并且由消息队列标识符标识，用户可以在消息队列中添加消息和读取消息等操作。

特点：是双向数据流，并且当没有读取到队列中的消息时，会阻塞等待。

消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define TYPEA 100
#define TYPEB 200
struct msgbuf
{
long mtype;
char mtext[64];
};
int main(int argc, const char *argv[])
{
pid_t pid;
int len;
struct msgbuf msg;
key_t key;
int msgid;
len = sizeof(msg) - sizeof(long);
key = ftok(".",'a');
msgid = msgget(key,0666 | IPC_CREAT);
pid = fork();
if(pid < 0)
{
perror("fail to fork");
return -1;
}
else if(pid == 0)
{
while(1)
{
fgets(msg.mtext,64,stdin);
msg.mtype = TYPEB;
msgsnd(msgid,&msg,len,0);
if(strncmp(msg.mtext,"quit",4) == 0)
{
kill(getppid(),SIGKILL);
exit(0);
}
}
}
else
{
while(1)
{
msgrcv(msgid,&msg,len,TYPEA,0);
printf("read from msg:%s",msg.mtext);
if(strncmp(msg.mtext,"quit",4) == 0)
{
kill(pid,SIGKILL);
wait(NULL);
msgctl(msgid,IPC_RMID,NULL);
exit(0);
}
}
}
return 0;
}

(3)信号灯集：是不同进程间或者是同一进程间不同线程间同步的机制。

共享资源的获取：

1.测试控制资源的信号量；

2.若信号量的值为正，则进程可以使用该资源。进程将信号量减一，表示它使用了一个资源单位。

3.若信号量的值为负，进程进入休眠状态，直到信号量值大于0 。进程被唤醒后，返回第一步。

当进程不再使用由一个信号量控制的共享资源时，该信号量减1.如果有进程正在休眠等待此信号，则唤醒他们。

为了正确的实现信号量，信号量的测试操作以及减1 操作都是原子操作。为此，信号量通常是在内核中实现。

常用的信号量形式被称为二元信号量或者是双态信号量。它控制单个资源，初始值为1 。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>
union semun
{
int val;
};
//0：write信号灯 1：read信号灯
int main(int argc, const char *argv[])
{
key_t key;
int semid,shmid;
union semun myun;
char * p;
struct sembuf buf;
key = ftok(".",'b');
if((semid = semget(key,2,IPC_CREAT | IPC_EXCL | 0666)) < 0)
{
if(errno == EEXIST)
{
semid = semget(key,2,0666);
}
else
{
perror("fail to semget");
return -1;
}
}
else
{//先运行，对信号灯集进行初始化
myun.val = 1;//write
semctl(semid,0,SETVAL,myun);
myun.val = 0;//read
semctl(semid,1,SETVAL,myun);
}
shmid = shmget(key,64,IPC_CREAT | 0666);
p = (char *)shmat(shmid,NULL,0);

while(1)
{
//对read进行p操作（申请读资源）
buf.sem_num = 1;
buf.sem_op = -1;
buf.sem_flg = 0;
semop(semid,&buf,1);
printf("read from shm :%s",p);
//对write进行v操作（释放写资源）
buf.sem_num = 0;
buf.sem_op = 1;
buf.sem_flg = 0;
semop(semid,&buf,1);
}

return 0;
}

由于不同的进程运行在各自不同的内存空间中．一方对于变量的修改另一方是无法感知的．因此．进程之间的信息传递不可能通过变量或其它数据结构直接进行，只能通过进程间通信来完成。

根据进程通信时信息量大小的不同，可以将进程通信划分为两大类型：控制信息的通信和大批数据信息的通信．前者称为低级通信，后者称为高级通信。

低级通信主要用于进程之间的同步、互斥、终止、挂起等等控制信息的传递。

高级通信主要用于进程间数据块的交换和共享 常见的高级通信有管道(PIPE)、消息队列(MESSAGE)、共享内存(SHARED MEM0RY)等。

这里主要比较一下高级通信的这三种方式的特点。

管道通信(PIPE)
两个进程利用管道进行通信时．发送信息的进程称为写进程．接收信息的进程称为读进程。管道通信方式的中间介质就是文件．通常称这种文件为管道文件．它就像管道一样将一个写进程和一个读进程连接在一起，实现两个进程之间的通信。写进程通过写入端(发送端)往管道文件中写入信息；读进程通过读出端(接收端)从管道文件中读取信息。两个进程协调不断地进行写和读，便会构成双方通过管道传递信息的流水线。
利用系统调用PIPE()可以创建一个无名管道文件，通常称为无名管道或PIPE；利用系统调用MKNOD()可以创建一个有名管道文件．通常称为有名管道或FIFO。无名管道是一种非永
久性的管道通信机构．当它访问的进程全部终止时，它也将随之被撤消。无名管道只能用在具有家族联系的进程之间。有名管道可以长期存在于系统之中．而且提供给任意关系的进程使用，但是使用不当容易导致出错．所以操作系统将命名管道的管理权交由系统来加以控制管道文件被创建后，可以通过系统调用WRITE()和READ()来实现对管道的读写操作；通信完后，可用CLOSE()将管道文件关闭。

消息缓冲通信(MESSAGE)
多个独立的进程之间可以通过消息缓冲机制来相互通信．这种通信的实现是以消息缓冲区为中间介质．通信双方的发送和接收操作均以消息为单位。在存储器中，消息缓冲区被组织成队列，通常称之为消息队列。消息队列一旦创建后即可由多进程共享．发送消息的进程可以在任意时刻发送任意个消息到指定的消息队列上，并检查是否有接收进程在等待它所发送的消息。若有则唤醒它：而接收消息的进程可以在需要消息的时候到指定的消息队列上获取消息．如果消息还没有到来．则转入睡眠状态等待。

共享内存通信(SHARED MEMORY)
针对消息缓冲需要占用CPU进行消息复制的缺点．OS提供了一种进程间直接进行数据交换的通信方式一共享内存 顾名思义．这种通信方式允许多个进程在外部通信协议或同步，互斥机制的支持下使用同一个内存段(作为中间介质)进行通信．它是一种最有效的数据通信方式，其特点是没有中间环节．直接将共享的内存页面通过附接．映射到相互通信的进程各自的虚拟地址空间中．从而使多个进程可以直接访问同一个物理内存页面．如同访问自己的私有空间一样(但实质上不是私有的而是共享的)。因此这种进程间通信方式是在同一个计算机系统中的诸进程间实现通信的最快捷的方法．而它的局限性也在于此．即共享内存的诸进程必须共处同一个计算机系统．有物理内存可以共享才行。

三种方式的特点（优缺点）：

1.无名管道简单方便．但局限于单向通信的工作方式．并且只能在创建它的进程及其子孙进程之间实现管道的共享：有名管道虽然可以提供给任意关系的进程使用．但是由于其长期存在于系统之中，使用不当容易出错。

2.消息缓冲可以不再局限于父子进程．而允许任意进程通过共享消息队列来实现进程间通信．并由系统调用函数来实现消息发送和接收之间的同步．从而使得用户在使用消息缓冲进行通信时不再需要考虑同步问题．使用方便，但是信息的复制需要额外消耗CPU的时间．不适宜于信息量大或操作频繁的场合。

3.共享内存针对消息缓冲的缺点改而利用内存缓冲区直接交换信息，无须复制，快捷、信息量大是其优点。但是共享内存的通信方式是通过将共享的内存缓冲区直接附加到进程的虚拟地址空间中来实现的．因此，这些进程之间的读写操作的同步问题操作系统无法实现。必须由各进程利用其他同步工具解决。另外，由于内存实体存在于计算机系统中．所以只能由处于同一个计算机系统中的诸进程共享。不方便网络通信。