Linux进程通信-共享内存

一、共享内存介绍

共享内存是IPC(Inter-Process Communication)机制中的一个。
它允许两个不相关的进程访问同一个逻辑内存。
共享内存是在两个正在进行的进程之间传递数据的一种非常有效的方式。
大多数的共享内存的实现，
都把由不同进程之间共享的内存安排为同一段物理内存。

共享内存是由IPC为进程创建一个特殊的地址范围，
它将出现在该进程的地址空间中。
其他进程可以将同一段共享内存连接它们自己的地址空间中。
所有进程都可以访问共享内存中的地址，
就好像它们是由malloc分配的一样。

如果某个进程向共享内存写入了数据，
所做的改动将立刻被可以访问同一段共享内存的任何其他进程看到。

二、共享内存的同步

共享内存为在多个进程之间共享和传递数据提供了一种有效的方式。
但是它并未提供同步机制，
所以我们通常需要用其他的机制来同步对共享内存的访问。
我们通常是用共享内存来提供对大块内存区域的有效访问，
同时通过传递小消息来同步对该内存的访问。

在第一个进程结束对共享内存的写操作之前，
并无自动的机制可以阻止第二个进程开始对它进行读取。
对共享内存访问的同步控制必须由程序员来负责。
下图显示了共享内存是如何共存的:

图中的箭头显示了每个进程的逻辑地址空间到可用物理内存的映射关系。

三、共享内存使用的函数

Linux提供了两种方式实现共享内存，一种是SystemV，还有一种是Posix标准。

SystemV：与信号量一样，在Linux中也提供了一组函数接口用于使用共享内存，而且使用共享共存的接口还与信号量的非常相似，而且比使用信号量的接口来得简单。它们声明在头文件 sys/shm.h中。
//创建共享内存:
int shmget(key_t key, size_t size, int shmflg);
//将其连接到一个进程的地址空间
void *shmat(int shm_id, const void *shm_addr, int shmflg);
//将共享内存从当前进程中分离,并未删除它,只是使得该共享内存对当前进程不再可用
int shmdt(const void *shm_addr);
//共享内存的控制函数
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

Posix:采用了文件映射内存的方式，创建的文件在/dev/shm目录下。通过以下接口实现：
//创建或打开一个共享内存,成功返回一个整数的文件描述符，错误返回-1
int shm_open(const char *name, int oflag, mode_t mode);
//会将参数fd指定的文件大小改为参数length指定的大小
int ftruncate(int fd,off_t length);
//将一个文件或者其它对象映射进内存,返回被映射区的指针
void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);
//取消参数start所指的映射内存起始地址，参数length则是欲取消的内存大小
int munmap(void* start,size_t length);

编译时要加库文件-lrt。

注意：不管是SystemV，还是Posix，共享内存被删除（ipcrm命令或者删除/dev/shm下的文件），两个进程只要不重启，依然能够通信，不受影响。但是如果有一方重新打开共享内存，双方访问的共享内存就不是同一片了，那么双方将无法通信。

四、示例

以下示例用SystemV 标准的共享内存实现。
典型的读者-写者程序，
第一个程序(读者)将创建一个共享内存段，然后把写到它里面的数据都取出来。
第二个程序(写者)将连接一个已有的共享内存段，并允许我们向其中输入数据。

读者进程：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/shm.h>
#include <string.h>
#include "shmdata.h"

int main()
{
    int running = 1;//程序是否继续运行的标志
    void *shm = NULL;//分配的共享内存的原始首地址
    struct shared_use_st *shared;//指向shm
    int shmid;//共享内存标识符
    //创建共享内存
    shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);
    if(shmid == -1)
    {
        fprintf(stderr, "shmget failed\n");
        exit(EXIT_FAILURE);
    }
    //将共享内存连接到当前进程的地址空间
    shm = shmat(shmid, 0, 0);
    if(shm == NULL)
    {
        fprintf(stderr, "shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf("\nMemory attached at %X\n", shm);
    //设置共享内存
    shared = (struct shared_use_st*)shm;
    shared->written = 0;
    while(running)//读取共享内存中的数据
    {
        //没有进程向共享内存定数据有数据可读取
        if(shared->written != 0)
        {
            printf("You wrote: %s", shared->text);
            sleep(rand() % 3);
            //读取完数据，设置written使共享内存段可写
            shared->written = 0;
            //输入了end，退出循环（程序）
            if(strncmp(shared->text, "end", 3) == 0)
                running = 0;
        }
        else//有其他进程在写数据，不能读取数据
            sleep(1);
    }
    //把共享内存从当前进程中分离
    if(shmdt(shm) == -1)
    {
        fprintf(stderr, "shmdt failed\n");
        exit(EXIT_FAILURE);
    }
    //删除共享内存
    if(shmctl(shmid, IPC_RMID, 0) == -1)
    {
        fprintf(stderr, "shmctl(IPC_RMID) failed\n");
        exit(EXIT_FAILURE);
    }
    exit(EXIT_SUCCESS);
}

写者进程：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/shm.h>
#include "shmdata.h"

int main()
{
    int running = 1;
    void *shm = NULL;
    struct shared_use_st *shared = NULL;
    char buffer[BUFSIZ + 1];//用于保存输入的文本
    int shmid;
    //创建共享内存
    shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);
    if(shmid == -1)
    {
        fprintf(stderr, "shmget failed\n");
        exit(EXIT_FAILURE);
    }
    //将共享内存连接到当前进程的地址空间
    shm = shmat(shmid, 0, 0);
    if(shm == NULL)
    {
        fprintf(stderr, "shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf("Memory attached at %X\n", shm);
    //设置共享内存
    shared = (struct shared_use_st*)shm;
    while(running)//向共享内存中写数据
    {
        //数据还没有被读取，则等待数据被读取,不能向共享内存中写入文本
        while(shared->written == 1)
        {
            sleep(1);
            printf("not read,locked,Waiting...\n");
        }
        //向共享内存中写入数据
        printf("Enter some text: ");
        fgets(buffer, BUFSIZ, stdin);
        strncpy(shared->text, buffer, TEXT_SZ);
        //写完数据，设置written使共享内存段可读
        shared->written = 1;
        //输入了end，退出循环（程序）
        if(strncmp(buffer, "end", 3) == 0)
            running = 0;
    }
    //把共享内存从当前进程中分离
    if(shmdt(shm) == -1)
    {
        fprintf(stderr, "shmdt failed\n");
        exit(EXIT_FAILURE);
    }
    sleep(2);
    exit(EXIT_SUCCESS);
}

头文件：

#ifndef _SHMDATA_H_HEADER
#define _SHMDATA_H_HEADER

#define TEXT_SZ 2048

struct shared_use_st
{
    int written;//作为一个标志，非0：表示可读，0表示可写
    char text[TEXT_SZ];//记录写入和读取的文本
};

#endif

这里提供的同步标志变量written，来实现读写进程互斥访问，它是一个非常缺乏效率的忙等待(不停地循环)。
而在实际编程中，应该使用信号量，或通过传递消息(使用管道或IPC消息)，或生成信号的方法来提供读写之间的更有效的同步机制。