分布式共享内存

这里，我们介绍两种分布式共享内存，一种是分布式共享内存，另外一种是naive分布式共享内存

简单的分布式共享内存 



所有的进程去访问一个共享内存，这个共享内存是虚拟的，他可能分布在不同的物理机上，其实可以理解为一种抽象，他整合了所有的存储资源，然后所有的调度、分配、读写都对程序员是隐藏的，他提供给程序员的就是一个虚拟的内存块（或者内存管理平台），程序员就可以向操作一块磁盘一样去在上进行编程或者其他的行为，这有点类似于云计算的思想。

naive分布式共享内存 

 

每一个机器都有一个存储内容的本地副本，读取操作我们可以从本地内存进行读取，写入操作我们可以先在本地下写入之后，再通过广播向其他的内存块发送update消息。

我们可以看到naive方式的共享内存速度是非常快的，因为他不需要去跟其他的用户进行交流，省去了通信的消耗。

 

共享内存是进程间通信(Inter Process Communication)的最快方式。linux共享内存有两种方式：
第一种：mmap方式，适用场景：父子进程之间，创建的内存非常大时
第二种：shmget方式，适用场景：同一台电脑上不同进程之间，创建的内存相对较小时
两种方式的文档网上都有很多，随便一抓一把。
通病：共享内存没有自带的同步机制，需要借助其他方式来进行同步。


nginx使用了mmap方式，并且对windows和linux都做了共享内存简单封装，需要使用可以参照学习一下(linux:\src\os\unix\ngx_shmem.h和\src\os\unix\ngx_shmem.c windows:\src\os\win32\ngx_shmem.h和windows:\src\os\win32\ngx_shmem.c

共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存一样。而如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。


特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取。所以我们通常需要用其他的机制来同步对共享内存的访问
2.
与信号量一样，在Linux中也提供了一组函数接口用于使用共享内存，而且使用共享共存的接口还与信号量的非常相似，而且比使用信号量的接口来得简单。它们声明在头文件 sys/shm.h中。
 shmget函数


例题：
下面有关共享内存，说法不正确的是？



共享内存和使用信号量一样，属于进程间通信的一种方式。


使用shmget函数来创建共享内存


尽管每个进程都有自己的内存地址，不同的进程可以同时将同一个内存页面映射到自己的地址空间中，从而达到共享内存的目的


共享内存提供了同步机制，在第一个进程结束对共享内存的写操作之前，会有自动机制可以阻止第二个进程开始对它进行读取

解答：D

参考文献：
Linux进程间通信——使用共享内存
Linux进程间通信——使用信号量

一 消息队列方式
     Linux消息队列是链式队列，链队上每个结点都是一个消息。一个进程可以将某一消息加入消息队列中，另一个进程可以从此消息队列中读取消息。一个典型的案例如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define SIZE 1024
const long id = 1000;
/*
 * a example to send and receive message 
 * */
int main() {
    key_t unique_key;
    int msgid;
    int status;
    char str[SIZE];
       
    struct msgbuf {
	long msgtype;
	char msgtext[SIZE];
    }sndmsg, rcvmsg;

    /*
     * get the identifier of a message queue
     * if the new message queue is created then msgget return the id 
     * else return -1 
     * */
    if((msgid = msgget(unique_key, IPC_PRIVATE |  0666)) == -1) {
	fprintf(stderr, "msgget error!\n");
	exit(1);
    }
    
    int pid = fork();
    if(pid == 0) {
	sndmsg.msgtype = id;
	strcpy(str, "Hello World, I am wangzhicheng!\n");
	sprintf(sndmsg.msgtext, str);
	/*
	 * send  message to message queue
	 * */
	if(msgsnd(msgid, (struct msgbuf *)&sndmsg, sizeof(str) + 1, 0) == -1) {
	    fprintf(stderr, "msgsnd error! \n");
	    exit(2);
	}
	return 0;
    }
    else if(pid > 0) {
	sleep(3);
	if((status = msgrcv(msgid, (struct msgbuf *)&rcvmsg, sizeof(str) + 1, id, IPC_NOWAIT)) == -1) {
	    fprintf(stderr, "msgrcv error!\n");
	    exit(4);
	}
	printf("The received message is:%s\n", rcvmsg.msgtext);
	msgctl(msgid, IPC_RMID, 0);   // delete the message queue 
	return 0;
    }
    else {
	fprintf(stderr, "fork error!\n");
	msgctl(msgid, IPC_RMID, 0);
	exit(5);
    }
}

要点分析：

1. msgget(long key, int msgflag)函数用于创建消息队列，key可由用户设定，msgflag指明了消息队列的操作权限和控制命令。0666表示此消息队列可读写，IPC_PRIVATE表示创建自己的消息队列。
2.  当父进程fork出子进程后，子进程使用msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)函数来将消息挂载到消息队列中，其中msgp指向消息缓存，msgfla表明进程在消息队列满或空应采取的行动，IPC_NOWAIT表示当消息队列为空时，函数返回错误信息。
3. 当子进程执行完毕后，父进程使用msgrcv函数从消息队列中取出消息。之所以要让父进程休眠3秒，就是要等子进程把消息挂载到消息队列上。
4. 消息队列可通过函数msgctl和关键字IPC_RM(remove)ID回收。
执行结果：


二 共享内存方式
共享内存是进程间通信最快的一种方式，还是以上述案例为基础，修改后代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <string.h>
#include <error.h>

#define SIZE 1024         // the size of shm 
/*
 * the father process fork the child process and shm 
 * the child process put data into the shm 
 * the father process read data from shm 
 * */
int main() {
    int shmid;
    char *shmaddr;
    struct shmid_ds buf;    // the structure of shm 

    int flag = 0;
    int pid;

    // 0600 means permission
    shmid = shmget(IPC_PRIVATE, SIZE, IPC_CREAT | 0600);
    if(shmid < 0) {
	perror("get shm id error!\n");
	exit(1);
    }

    pid = fork();
    if(pid == 0) {
	shmaddr = (char *)shmat(shmid, NULL, 0);
	if(shmaddr == (void*)(-1)) {
	    perror("shmat addr error!\n");
	    exit(2);
	}
	strcpy(shmaddr, "Hello World, I am wangzhicheng!\n");
	shmdt(shmaddr);            // to forbid process to access the shm 
	return 0;
    }
    else if(pid > 0) {
	sleep(3);
	flag = shmctl(shmid, IPC_STAT, &buf); // to copy the shm state to buf 
	if(flag == -1) {
	    perror("shmctl error!\n");
	    exit(3);
	}
	printf("shm size =%d bytes \n", buf.shm_segsz);
	// getpid() pointer to  the current program 
	printf("parent id = %d, shm_cpid =%d\n", getpid(), buf.shm_cpid); // shm_cpid means the id of created the shm 
	printf("child pid = %d, shm_lpid = %d\n", pid, buf.shm_lpid);     // shm_lpid meansns the last process id 

	shmaddr = (char *)shmat(shmid, NULL, 0);
	if(shmaddr == (void *)(-1)) {
	    perror("shmat error!\n");
	    exit(4);
	}
	puts(shmaddr);
	shmdt(shmaddr);
	shmctl(shmid, IPC_RMID, NULL);    // remove the shm 
    }
    else {
	perror("fork error!\n");
	shmctl(shmid, IPC_RMID, NULL);
    }

    return 0;
}

要点分析：

1. shmget用于获取共享内存，IPC_CREAT和0600指明了创建一个可读写的共享内存。
2. shmat用于将共享内存映射到进程内存空间，让进程可以像在自己的地址空间里访问共享内存。
3. 子进程被创建后将字符串写入shmaddr所指向的共享内存中。
4. 父进程同样使用shmat进行地址映射，然后从共享内存中读取数据。
5. shmdt表明进程断开与共享内存的地址映射。
6. shmctl和IPC_RMID用于共享内存的回收。
执行结果：