2017-2018-1 20155317 IPC
- 共享内存
共享内存主要是通过映射机制实现的。以window系统调用为例子：Windows 下进程的地址空间在逻辑上是相互隔离的，但在物理上却是重叠的。所谓的重叠是指同一块内存区域可能被多个进程同时使用。当调用 CreateFileMapping 创建命名的内存映射文件对象时，Windows 即在物理内存申请一块指定大小的内存区域，返回文件映射对象的句柄 hMap。为了能够访问这块内存区域必须调用 MapViewOfFile 函数，促使 Windows 将此内存空间映射到进程的地址空间中。当在其他进程访问这块内存区域时，则必须使用OpenFileMapping 函数取得对象句柄 hMap，并调用 MapViewOfFile 函数得到此内存空间的一个映射。这样一来，系统就把同一块内存区域映射到了不同进程的地址空间中，从而达到共享内存的目的。
#include <iostream>
#include <windows.h>
#include <string>
#include <cstring>
using namespace std; int main() {
string strMapName("ShareMemory"); // 内存映射对象名称
string strComData("This is common data!"); // 共享内存中的数据
LPVOID pBuffer; // 共享内存指针 // 首先试图打开一个命名的内存映射文件对象
HANDLE hMap = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, , strMapName.c_str());
if (NULL == hMap)
{
// 打开失败，创建之
hMap = ::CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,,strComData.length()+,strMapName.c_str());
// 映射对象的一个视图，得到指向共享内存的指针，设置里面的数据
pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, , , );
strcpy((char*)pBuffer, strComData.c_str());
cout << "写入共享内存数据：" << (char *)pBuffer << endl; }
else
{
// 打开成功，映射对象的一个视图，得到指向共享内存的指针，显示出里面的数据
pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, , , );
cout << "读取共享内存数据：" << (char *)pBuffer << endl; } getchar(); // 注意，进程关闭后，所有句柄自动关闭，所以要在这里暂停 // 解除文件映射，关闭内存映射文件对象句柄
::UnmapViewOfFile(pBuffer);
::CloseHandle(hMap);
system("pause");
return ; }
- 管道
管道是一种半双工的通信方式
数据只能单向流动，而且只能在具有共同祖先的进程间使用。 所谓半双工的模式（以下是我的理解）： 形象来说类似一个单刀双掷开关，有两个选择，但是二者是互斥的，当选择了一方另一方就失效。 而对于此处的管道，可以把它想成是管道的一端，一次只能调用一种功能读入或者写入，二者也是互斥的。 同时对应的fd[0]与fd[1]其实是一个类似一个临界区的资源，一次只能由一个进程使用一种功能，所以使用时要注意分配读和写的功能。
父进程创建管道和两个子进程p1和p2
¢2.子进程p1打开给定文件（如果没有，则创建文件），并向文件中写数据，写完关闭文件，然后向管道写入一条消息“ok"，目的是通知进程p2可以读取文件内容了。
¢3.子进程p2通过管道读取消息，如果消息是“ok”,则打开文件，读取文件内容，并将其输出到屏幕上,关闭文件.
#include<stdio.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
#include<sys/wait.h>
int pid1,pid2; int main()
{
int fd[];
char outpipe[],inpipe[];
while((pid1 = fork()) == -);
if(pid1 == )
{
lockf(fd[], , );
sprintf(outpipe,"\n child process 1 is sending message!\n");
write(fd[], outpipe, );
sleep();
lockf(fd[], , );
exit();
}
else
{
while((pid2 = fork()) == -);
if(pid2 == )
{
lockf(fd[], , );
sprintf(outpipe,"\n child process 2 is sending message !\n");
write(fd[], outpipe, );
sleep();
lockf(fd[], , );
exit();
}
else
{
wait();
read(fd[], inpipe, );
printf("%s\n",inpipe);
wait();
read(fd[], inpipe, );
printf("%s\n",inpipe);
exit();
}
}
}
- FIFO
FIFO与管道类似，它们最大的差别是，FIFO在文件系统中拥有一个名称，并且其打开方式与打开一个普通文件是一样的，这样就能够将FIFO用于非相关进程之间的通信。
#include<sys/types.h>
.#include<sys/stat.h>
.#include<errno.h>
.#include<fcntl.h>
.#include<stdio.h>
.#include<stdlib.h>
.#include<string.h>
.#define FIFO_SERVER "./myfifo"
.main(int argc,char** argv)
.{
. int fd;
. char w_buf[];
. int nwrite;
. if(fd==-)
. if(errno==ENXIO)
. printf("open error;no reading process\n");
. fd=open(FIFO_SERVER,O_WRONLY|O_NONBLOCK,);
. if(argc==)
. printf("Please send something\n");
. strcpy(w_buf,argv[]);
. if((nwrite=write(fd,w_buf,))==-)
. {
. if(errno==EAGAIN)
. printf("The FIFO has not been read yet. Please try later\n");
. }
. else
. printf("write %s to the FIFO\n",w_buf);
.}
- 信号
信号实际上是软中断，既然是中断那么信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。 信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后，功能更加强大，除了基本通知功能外，还可以传递附加信息。
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
void new_op(int,siginfo_t*,void*);
int main(int argc,char**argv)
{
struct sigaction act;
union sigval mysigval;
int i;
int sig;
pid_t pid;
char data[];
mset(data,,sizeof(data));
for(i=; i < ; i++)
data[i]='';
mysigval.sival_ptr=data;
sig=atoi(argv[]);
p
sid=getpid();
sigemptyset(&act.sa_mask);
act.sa_sigaction=new_op;//三参数信号处理函数
act.sa_flags=SA_SIGINFO;//信息传递开关
if(sigaction(sig,&act,NULL) < )
{
printf("install sigal error\n");
}
while()
{
sleep();
printf("wait for the signal\n");
sigqueue(pid,sig,mysigval);//向本进程发送信号，并传递附加信息
}
}
void new_op(int signum,siginfo_t *info,void *myact)//三参数信号处理函数的实现
{
int i;
for(i=; i<; i++)
{
printf("%c\n ",(*( (char*)((*info).si_ptr)+i))); }
printf("handle signal %d over;",signum);
}
- 消息队列
“消息”是在两台计算机间传送的数据单位。消息可以非常简单，例如只包含文本字符串；也可以更复杂，可能包含嵌入对象。
消息被发送到队列中。“消息队列”是在消息的传输过程中保存消息的容器。消息队列管理器在将消息从它的源中继到它的目标时充当中间人。队列的主要目的是提供路由并保证消息的传递；如果发送消息时接收者不可用，消息队列会保留消息，直到可以成功地传递它。
“消息队列”是 Microsoft 的消息处理技术，它在任何安装了 Microsoft Windows 的计算机组合中，为任何应用程序提供消息处理和消息队列功能，无论这些计算机是否在同一个网络上或者是否同时联机。
“消息队列网络”是能够相互间来回发送消息的任何一组计算机。网络中的不同计算机在确保消息顺利处理的过程中扮演不同的角色。它们中有些提供路由信息以确定如何发送消息，有些保存整个网络的重要信息，而有些只是发送和接收消息。
“消息队列”安装期间，管理员确定哪些服务器可以互相通信，并设置特定服务器的特殊角色。构成此“消息队列”网络的计算机称为“站点”，它们之间通过“站点链接”相互连接。每个站点链接都有一个关联的“开销”，它由管理员确定，指示了经过此站点链接传递消息的频率。
“消息队列”管理员还在网络中设置一台或多台作为“路由服务器”的计算机。路由服务器查看各站点链接的开销，确定经过多个站点传递消息的最快和最有效的方法，以此决定如何传递消息。
#include < stdio.h >
#include < stdlib.h >
#include < ctype.h >
#include < sys / ipc.h >
#include < sys / types.h >
#include < sys / msg.h > #define MAX_SEND_SIZE 80 struct mymsgbuf
{
long mtype;
char mtext[MAX_SEND_SIZE];
} ;
void send_message( int qid, struct mymsgbuf * qbuf, long type, char * text);
void read_message( int qid, struct mymsgbuf * qbuf, long type);
void remove_queue( int qid);
void change_queue_mode( int qid, char * mode);
void usage( void ); int main( int argc, char * argv[])
{
key_t key;
int msgqueue_id;
struct mymsgbuf qbuf; if ( == argc)
usage();
key = ftok( " . " , ' m ' );
if ((msgqueue_id = msgget(key,IPC_CREAT | )) ==- )
{
perror( " msgget " );
exit( );
}
switch (tolower(argv[ ][ ]))
{
case ' s ' :
send_message(msgqueue_id,( struct mymsgbuf * ) & qbuf,
atol(argv[ ]),argv[ ]);
break ;
case ' r ' :
read_message(msgqueue_id, & qbuf,atol(argv[ ]));
break ;
case ' d ' :
remove_queue(msgqueue_id);
break ;
case ' m ' :
change_queue_mode(msgqueue_id,argv[ ]);
break ;
default :
usage();
}
return ;
}
void send_message( int qid, struct mymsgbuf * qbuf, long type, char * text)
{
printf( " send a message /n " );
qbuf -> mtype = type;
strcpy(qbuf -> mtext,text);
if ((msgsnd(qid,( struct msgbuf * )qbuf,strlen(qbuf -> mtext) + , )) ==- )
{
perror( " msgsnd " );
exit( );
}
}
void read_message( int qid, struct mymsgbuf * qbuf, long type)
{
printf( " reading a message./n " );
qbuf -> mtype = type;
msgrcv(qid,( struct msgbuf * )qbuf,MAX_SEND_SIZE,type, );
printf( " Type: %1d Text: %s/n " ,qbuf -> mtype,qbuf -> mtext);
}
void remove_queue( int qid)
{
msgctl(qid,IPC_RMID, );
}
void change_queue_mode( int qid, char * mode)
{
struct msqid_ds myqueue_ds;
msgctl(qid,IPC_STAT, & myqueue_ds);
sscanf(mode, " %ho " , & myqueue_ds.msg_perm.mode);
msgctl(qid,IPC_SET, & myqueue_ds);
}
void usage( void )
{
fprintf(stderr, " msgtool -A utility for tinkering with msg queue/n " );
fprintf(stderr, " /nUSAGE:msgtool (s)end <type> <messagetext>/n " );
fprintf(stderr, " (r)ecv<type>/n " );
fprintf(stderr, " (d)elete/n " );
fprintf(stderr, " (m)ode<octal mode>/n " );
exit( );
}