2017-2018-1 20155317 IPC

Posted 2020-10-17

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, 0, strMapName.c_str());
    if (NULL == hMap)
    {
        // 打开失败，创建之
        hMap = ::CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,strComData.length()+1,strMapName.c_str());
        // 映射对象的一个视图，得到指向共享内存的指针，设置里面的数据
        pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
        strcpy((char*)pBuffer, strComData.c_str());
        cout << "写入共享内存数据：" << (char *)pBuffer << endl;

    }
    else
    {
        // 打开成功，映射对象的一个视图，得到指向共享内存的指针，显示出里面的数据
        pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
        cout << "读取共享内存数据：" << (char *)pBuffer << endl;

    }

    getchar(); // 注意，进程关闭后，所有句柄自动关闭，所以要在这里暂停

    // 解除文件映射，关闭内存映射文件对象句柄
    ::UnmapViewOfFile(pBuffer);
    ::CloseHandle(hMap);
    system("pause");
    return 0;

}

 

- 管道

?管道是一种半双工的通信方式

?数据只能单向流动，而且只能在具有共同祖先的进程间使用。 所谓半双工的模式（以下是我的理解）： 形象来说类似一个单刀双掷开关，有两个选择，但是二者是互斥的，当选择了一方另一方就失效。 而对于此处的管道，可以把它想成是管道的一端，一次只能调用一种功能读入或者写入，二者也是互斥的。 同时对应的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[2];  
    char outpipe[100],inpipe[100];  
    while((pid1 = fork()) == -1);  
    if(pid1 == 0)  
    {  
        lockf(fd[1], 1, 0);  
        sprintf(outpipe,"\n child process 1 is sending message!\n");  
        write(fd[1], outpipe, 50);  
        sleep(5);  
        lockf(fd[1], 0, 0);  
        exit(0);  
    }  
    else  
    {  
        while((pid2 = fork()) == -1);  
        if(pid2 == 0)  
        {  
            lockf(fd[1], 1, 0);  
            sprintf(outpipe,"\n child process 2 is sending message !\n");  
            write(fd[1], outpipe, 50);  
            sleep(5);  
            lockf(fd[1], 0, 0);  
            exit(0);  
        }  
        else  
        {  
            wait(0);  
            read(fd[0], inpipe, 50);  
            printf("%s\n",inpipe);  
            wait(0);  
            read(fd[0], inpipe, 50);  
            printf("%s\n",inpipe);  
            exit(0);  
        }  
    }  
}  

 

- FIFO

FIFO与管道类似，它们最大的差别是，FIFO在文件系统中拥有一个名称，并且其打开方式与打开一个普通文件是一样的，这样就能够将FIFO用于非相关进程之间的通信。

#include<sys/types.h>  
2.#include<sys/stat.h>  
3.#include<errno.h>  
4.#include<fcntl.h>  
5.#include<stdio.h>  
6.#include<stdlib.h>  
7.#include<string.h>  
8.#define FIFO_SERVER "./myfifo"  
9.main(int argc,char** argv)  
10.{  
11.    int fd;  
12.    char w_buf[100];  
13.    int nwrite;  
14.    if(fd==-1)  
15.        if(errno==ENXIO)  
16.            printf("open error;no reading process\n");  
17.    fd=open(FIFO_SERVER,O_WRONLY|O_NONBLOCK,0);  
18.    if(argc==1)  
19.        printf("Please send something\n");  
20.    strcpy(w_buf,argv[1]);  
21.    if((nwrite=write(fd,w_buf,100))==-1)  
22.    {  
23.        if(errno==EAGAIN)  
24.            printf("The FIFO has not been read yet. Please try later\n");  
25.    }  
26.    else   
27.        printf("write %s to the FIFO\n",w_buf);  
28.} 

 

- 信号

信号实际上是软中断，既然是中断那么信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。 信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过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[10];
    mset(data,0,sizeof(data));
    for(i=0; i < 5; i++)
        data[i]=‘2‘;
    mysigval.sival_ptr=data;
    sig=atoi(argv[1]);
    p
    sid=getpid();
    sigemptyset(&act.sa_mask);
    act.sa_sigaction=new_op;//三参数信号处理函数
    act.sa_flags=SA_SIGINFO;//信息传递开关
    if(sigaction(sig,&act,NULL) < 0)
    {
        printf("install sigal error\n");
    }
    while(1)
    {
        sleep(2);
        printf("wait for the signal\n");
        sigqueue(pid,sig,mysigval);//向本进程发送信号，并传递附加信息
    }
}
void new_op(int signum,siginfo_t *info,void *myact)//三参数信号处理函数的实现
{
    int i;
    for(i=0; i<10; 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 ( 1 == argc)
        usage();
    key = ftok( " . " , ‘ m ‘ );
    if ((msgqueue_id = msgget(key,IPC_CREAT | 0660 )) ==- 1 )
    {
        perror( " msgget " );
        exit( 1 );
    }
    switch (tolower(argv[ 1 ][ 0 ]))
    {
    case   ‘ s ‘ :
        send_message(msgqueue_id,( struct  mymsgbuf  * ) & qbuf,
                     atol(argv[ 2 ]),argv[ 3 ]);
        break ;
    case   ‘ r ‘ :
        read_message(msgqueue_id, & qbuf,atol(argv[ 2 ]));
        break ;
    case   ‘ d ‘ :
        remove_queue(msgqueue_id);
        break ;
    case   ‘ m ‘ :
        change_queue_mode(msgqueue_id,argv[ 2 ]);
        break ;
    default :
        usage();
    }
    return   0 ;
}
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) + 1 , 0 )) ==- 1 )
    {
        perror( " msgsnd " );
        exit( 1 );
    }
}
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, 0 );
    printf( " Type: %1d Text: %s/n " ,qbuf -> mtype,qbuf -> mtext);
}
void  remove_queue( int  qid)
{
    msgctl(qid,IPC_RMID, 0 );
}
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( 1 );
}