共享内存（进程间通信）

共享内存

1.1 特点

1）共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。

2）为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。

3)由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等.

1.2 步骤

a. 创建key值

b. 创建或打开共享内存

c. 映射共享内存到用户空间

d. 撤销映射

e. 删除共享内存

1.3 函数接口

key_t ftok(const char *pathname, int proj_id);
功能：创建出来的具有唯一映射关系的一个key值，帮助操作系统用来标识一块共享内存
参数：
    Pathname：已经存在的可访问文件的名字
    Proj_id：一个字符（因为只用低8位）
返回值：成功：key值
      失败：-1

int shmget(key_t key, size_t size, int shmflg);
功能：创建或打开共享内存
参数：
    key  键值
    size   共享内存的大小
    shmflg   IPC_CREAT|IPC_EXCL|0777
返回值：成功  shmid
      出错    -1
注意对错误的处理方式：
如果错误是file exist光打开共享内存不用设IPC_CREAT|IPC_EXCL了，加判断，如：if(errno == EEXIST)

void  *shmat(int  shmid,const  void  *shmaddr,int  shmflg); //attaches
功能：映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
参数：
    shmid   共享内存的id号
    shmaddr   一般为NULL，表示由系统自动完成映射
              如果不为NULL，那么有用户指定
    shmflg：SHM_RDONLY就是对该共享内存只进行读操作
                0     可读可写
返回值：成功：完成映射后的地址，
       出错：-1（地址）
用法：if((p = (char *)shmat(shmid，NULL,0)) == (char *)-1)

int shmdt(const void *shmaddr); //detaches
功能：取消映射
参数：要取消的地址
返回值：成功0  
      失败的-1

int  shmctl(int  shmid,int  cmd,struct shmid_ds *buf); //control
功能：(删除共享内存)，对共享内存进行各种操作
参数：
    shmid   共享内存的id号
    cmd     IPC_STAT 获得shmid属性信息，存放在第三参数
            IPC_SET 设置shmid属性信息，要设置的属性放在第三参数
            IPC_RMID:删除共享内存，此时第三个参数为NULL即可
    buf    shmid所指向的共享内存的地址,空间被释放以后地址就赋值为null
返回：成功0 
     失败-1
用法：shmctl(shmid,IPC_RMID,NULL);

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>

int main(int argc, char const *argv[])
{
    int shmid;
    key_t key;
    char *p;
    key = ftok("shm.c", 'a');
    if (key < 0)
    {
        perror("key err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建共享内存
    shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建，存在则返回-1
    if (shmid <= 0)
    {
        if (errno == EEXIST)                //如果共享内存已存在则，直接打开
            shmid = shmget(key, 128, 0777); //直接打开已有的共享内存并且获得共享内存id
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (char *)shmat(shmid, NULL,0);
    if(p == (char *)-1)
    {
        perror("shmat err");
        return -1;
    }

    //操作共享内存
    scanf("%s",p);
    printf("%s\n", p);

    //取消映射
    shmdt(p);

    //删除共享内存
    shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

进程间通信:

1.4. 命令：

ipcs -m: 查看系统中的共享内存

ipcrm -m shmid：删除共享内存

ps: 可能不能直接删除掉还存在进程使用的共享内存。

这时候可以用ps -ef对进程进行查看，kill掉多余的进程后，再使用ipcs查看。

练习：两个进程实现通信，一个进程循环从终端输入，另一个进程循环打印，当输入quit时结束

这两个标志在两个进程里，是不共享的，所以为了共享标志位可以和buf封装到一个结构体里作为共享内存。

struct msg

{

int flag;

char buf[32];

};

input:

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>
#include <string.h>

struct msg
{
    int flag;
    char buf[32];
};

int main(int argc, char const *argv[])
{
    int shmid;
    key_t key;
    struct msg *p;
    key = ftok("shm.c", 'a');
    if (key < 0)
    {
        perror("key err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建共享内存
    shmid = shmget(key, sizeof(struct msg), IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建，存在则返回-1
    if (shmid <= 0)
    {
        if (errno == EEXIST)                               //如果共享内存已存在则，直接打开
            shmid = shmget(key, sizeof(struct msg), 0777); //直接打开已有的共享内存并且获得共享内存id
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (struct msg *)shmat(shmid, NULL, 0);
    if (p == (struct msg *)-1)
    {
        perror("shmat err");
        return -1;
    }

    p->flag = 0;
    while (1)
    {
        if (p->flag == 0)
        {
            scanf("%s", p->buf);
            p->flag = 1;
        }
        if (strcmp(p->buf, "quit") == 0)
            break;
    }

    //取消映射
    shmdt(p);

    //删除共享内存
    //shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

output:

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>
#include <string.h>

struct msg
{
    int flag;
    char buf[32];
};

int main(int argc, char const *argv[])
{
    int shmid;
    key_t key;
    struct msg *p;
    key = ftok("shm.c", 'a');
    if (key < 0)
    {
        perror("key err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建共享内存
    shmid = shmget(key, sizeof(struct msg), IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建，存在则返回-1
    if (shmid <= 0)
    {
        if (errno == EEXIST)                               //如果共享内存已存在则，直接打开
            shmid = shmget(key, sizeof(struct msg), 0777); //直接打开已有的共享内存并且获得共享内存id
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (struct msg *)shmat(shmid, NULL, 0);
    if (p == (struct msg *)-1)
    {
        perror("shmat err");
        return -1;
    }

    p->flag = 0;
    while (1)
    {
        if (strcmp(p->buf, "quit") == 0)
            break;
        if (p->flag == 1)
        {
            printf("%s\n", p->buf);
            p->flag = 0;
        }
    }

    //取消映射
    shmdt(p);

    //删除共享内存
    //shmctl(shmid,IPC_RMID,NULL);

    return 0;
}