Linux | 进程间通信：共享内存

目录

1.共享内存的含义

2. 操作共享内存的接口 shmget shmat shmdt

3.共享内存示例（引入信号量控制读写）

---

1.共享内存的含义

共享内存为多个进程之间共享和传递数据提供了一种有效的方式。共享内存是先在物理内存上申请一块空间，多个进程可以将其映射到自己的虚拟地址空间中。所有进程都可以访问共享内存中的内容，如果某个进程向共享内存写入了数据或对其内容进行修改，那么所做的改动将立刻被访问同一共享内存的其它进程看到。

由于共享内存未提供同步机制，所以我们通常需要用其他的机制来同步对共享内存的访问（对共享内存的使用通常伴随信号量的控制）。

ipcs可以看系统中的消息队列、共享内存和信号量。 

• ipcs -m：可以查看共享内存。
• ipcs -s：可以查看信号量。

2. 操作共享内存的接口 shmget shmat shmdt

引入头文件：#include<sys/shm.h> 

（1）shmget()：创建或获取共享内存

int shmget(key_t key, size_t size, int shmflg);

• 成功返回共享内存的ID，失败返回-1。
• 参数1 key：不同的进程使用相同的 key 值可以获取到同一个共享内存。
• 参数size：创建共享内存时，指定要申请的共享内存空间大小。
• 参数shmflg: IPC_CREAT  IPC_EXCL
• 举例：int shmid=shmget((key_t)1234,128,IPC_CREAT|0600);

（2）shmat()：对申请来的共享内存进行映射

void* shmat(int shmid, const void *shmaddr, int shmflg); 

• shmat：将申请到的共享内存（物理内存）映射到某进程的虚拟内存
• 成功返回返回共享内存的首地址（将其强转为char*），失败返回 NULL。
• 参数shmaddr：一般给 NULL，由系统自动选择映射的虚拟地址空间。
• 参数shmflg： 一般给 0， 可以给 SHM_RDONLY 为只读模式，其他的为读写
• 举例：char* s=(char*)shmat(shmid,NULL,0);

（3）shmdt()：断开当前进程的对共享内存的映射

int shmdt(const void *shmaddr);

3.共享内存示例（引入信号量控制读写）

题目：一个程序不断向共享内存写入数据，另一个程序不断读取，直至读到"end"退出。

由于main.c中向共享内存写入一个值，test.c就会不断重复打印该值，未达到想要的效果。故引入2个信号量控制对共享内存的访问：只能写入一次读取一次。

• shm.h（信号量头文件）

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/sem.h>

#define SEM1 0
#define SEM2 1
#define SEMNUM 2//信号量个数2

union semun
{
    int val;
};

void sem_init();
void sem_p(int index);//pv操作针对具体某个信号量，故传如下标
void sem_v(int index);
void sem_destroy();

• shm.c（信号量操作）

#include"shm.h"
static int semid=-1;

void sem_init()
{
    semid=semget((key_t)1234,SEMNUM,IPC_CREAT|IPC_EXCL|0600);
    if(semid==-1)
    {
        semid=semget((key_t)1234,SEMNUM,0600);
        if(semid==-1)
        {
            printf("semget error!\n");
        }
    }
    else 
    {
        union semun a;
        int arr[SEMNUM]={1,0};//sem1 sem2初始化为1 0
        for(int i=0;i<SEMNUM;i++)
        {
            a.val=arr[i];
            if(semctl(semid,i,SETVAL,a)==-1)
            {
                printf("semctl init err\n");
            } 
        }
    }
}

void sem_p(int index)
{
    if(index<0||index>=SEMNUM)
    {
        return;
    }
    struct sembuf buf;
    buf.sem_num=index;//对下标为index的信号量进行p操作
    buf.sem_op=-1; 
    buf.sem_flg=SEM_UNDO;
    if(semop(semid,&buf,1)==-1)
    {
        printf("semop p err\n");
    }
}

void sem_v(int index)
{
    if(index<0||index>=SEMNUM)
    {
        return;
    }
    struct sembuf buf;
    buf.sem_num=index;//对下标为index的信号量进行v操作
    buf.sem_op=1;
    buf.sem_flg=SEM_UNDO;
    if(semop(semid,&buf,1)==-1)
    {
        printf("semop v err\n");
    }
}

void sem_destroy()
{
    if(semctl(semid,0,IPC_RMID)==-1)
    {
        printf("semctl destroy err\n");   
    }
}

• m1.c 对共享内存进行互斥写操作

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

int main()
{
    int shmid=shmget((key_t)1234,128,IPC_CREAT|0600);//创建共享内存（申请共享内存）
    if(shmid==-1)
    {
        printf("shmget err\n");
        exit(1);
    }

    char* s=(char*)shmat(shmid,NULL,0);//参数2为NULL，由系统自动选择映射的虚拟地址空间
    if(s==(char*)-1)//如果s==-1 失败，将-1转为(char*)进行比较
    {
        printf("shmat err\n");
        exit(1);
    }

    sem_init();
    while(1)
    {
        printf("input:\n");
        char buff[128]={0};
        fgets(buff,128,stdin);
        sem_p(SEM1);
        strcpy(s,buff);
        sem_v(SEM2);//写入程序一定要在break之前执行v操作，否则导致读程序阻塞
        if(strncmp(buff,"end",3)==0)
        {
            break;
        }
    }
    shmdt(s);//断开映射
}

• m2.c 对共享内存进行互斥读操作

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

int main()
{
    int shmid=shmget((key_t)1234,128,IPC_CREAT|0600);
    if(shmid==-1)
    {
        printf("shmget err\n");
        exit(1);
    }

    char* s=(char*)shmat(shmid,NULL,0);
    if(s==(char*)-1)
    {
        printf("shmat err\n");
        exit(1);
    }
    sem_init();
    while(1)
    {
        sem_p(SEM2);
        if(strncmp(s,"end",3)==0)
        {
            break;//读到"end"程序结束
        }
        printf("read:%s\n",s);
        sem_v(SEM1);
    }
    shmdt(s);
    sem_destroy();
}