• 进程间通信（IPC）：共享内存

    进程间通信 IPC ：管道、信号量、共享内存、消息队列、套接字

    进程间通信，两个进程间传递信息

    除了套接字，前面几个主要是在同一台主机上两个进程间通信

    共享内存

    共享内存为多个进程之间共享和传递数据提供了一种有效的方式。共享内存是先在物理内存上申请一块空间，多个进程可以将其映射到自己的虚拟地址空间中。所有进程都可以访问共享内存中的地址，就好像它们是由 malloc 分配的一样。如果某个进程向共享内存写入了 数据，所做的改动将立刻被可以访问同一段共享内存的任何其他进程看到。由于它并未提供同步机制，所以我们通常需要用其他的机制来同步对共享内存的访问。

    接口

    1. #include <sys/ipc.h>
    2. #include <sys/shm.h>
    3. #include <sys/types.h>

    int shmget(key_t key, size_t size, int shmflg); //创建共享内存

    shmget()  用于创建或者获取共享内存

    shmget()  成功返回共享内存的 ID， 失败返回-1

    key： 不同的进程使用相同的 key 值可以获取到同一个共享内存

    size： 创建共享内存时，指定要申请的共享内存空间大小，以字节为单位

    shmflg: 包含9个比特的权限标志

                 IPC_CREAT IPC_EXCL 

                 IPC_CREAT:存在则打开，不存在则创建

                 IPC_EXCL和IPC_CREAT同时使用存在则会报错，不存在创建；

                                                         （权限直接加在后面进行赋值）

    void* shmat(int shmid, const void *shmaddr, int shmflg); //映射，将共享内存映射到进程的地址空间

    shmat()  将申请的共享内存的物理内存映射到当前进程的虚拟地址空间上 

    shmat()  成功返回返回共享内存的首地址，失败返回 NULL

    shmaddr：一般给NULL，由系统自动选择映射的虚拟地址空间

    shmflg: 一组标志位，SHM_RND(这个标志与shm_addr联合使用，用来控制共享内存链接共享内存链接的地址)  SHM_RDONLY（它使得连接的内存只读），不指定时给0就可以

    int shmdt(const void *shmaddr); //断开映射

    shmdt()  断开当前进程的 shmaddr 指向的共享内存映射

    shmdt()  成功返回 0， 失败返回-1

    shmaddr  返回的地址指针

    int shmctl(int shmid, int cmd, struct shmid_ds *buf);  //控制共享内存，eg:删除

    shmctl()  控制共享内存

    shmctl()  成功返回 0，失败返回-1 

    cmd： 要采取的动作

                IPC_STAT   把shmid__ds结构中的数据设置为共亨内存的当前关联值
                IPC_SET     如果进程有足够的权限，就把共享内存的当前关联值设置为shmid_ds

                                    结构中给出的值
                IPC_RMID   删除共享内存段

    buf： 是一个指针，它指向包含共享内存模式和访问权限的结构。
     

    代码实现

    进程 a向共享内存中写入数据，进程 b 从共享内存中读取数据并显示 shma.c 的代码：

    a文件输入，b文件输出

    a.c文件

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<unistd.h>
    4. #include<string.h>
    5. #include<sys/shm.h>
    6.  
    7. int main()
    8. {
    9.     //创建共享内存
    10.     int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);//key值为1234，共享内存大小为128，IPC_CREAT 存在则打开，不存在创建，权限0600
    11.     if(shmid==-1)
    12.     {
    13.         printf("shmget err\n");//创建失败
    14.         exit(1);
    15.     }
    16.  
    17.     //映射，将共享内存映射到进程的地址空间
    18.     //映射成功后就可以通过指针s访问此空间
    19.     char*s=(char*)shmat(shmid,NULL,0);//shmat本身返回值void*类型,强转为char*，shmid 共享内存id，给NULL。系统自动选择映射的虚拟地址空间标志位不指定为0
    20.     if(s==(char *)-1)
    21.     {
    22.         printf("shmat err\n");//映射失败
    23.         exit(1);
    24.     }
    25.  
    26.     //向共享内存写入数据
    27.     strcpy(s,"hello");
    28.  
    29.     shmdt(s);//断开映射
    30.  
    31.     exit(0);
    32.  
    33. }
    34.                                                    
    35.

    b.c文件

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<unistd.h>
    4. #include<string.h>
    5. #include<sys/shm.h>
    6.  
    7. int main()
    8. {
    9.     //创建共享内存,存在就获取共享内存
    10.     int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);//key值为1234，共享内存大小为128，IPC_CREAT 存在则打开，不存在创建，权限0600
    11.     if(shmid==-1)
    12.     {
    13.         printf("shmget err\n");//创建失败
    14.         exit(1);
    15.     }
    16.  
    17.     //映射，将共享内存映射到进程的地址空间
    18.     //映射成功后就可以通过指针s访问此空间
    19.     char*s=(char*)shmat(shmid,NULL,0);//shmat本身返回值void*类型,强转为char*，shmid 共享内存id，给NULL。系统自动选择映射的虚拟地址空间 标
    20. 志位不指定为0
    21.     if(s==(char *)-1)
    22.     {
    23.         printf("shmat err\n");//映射失败
    24.         exit(1);
    25.     }
    26.  
    27.     //用test文件读取共享内存空间中的值
    28.     printf("read:%s\n",s);
    29.  
    30.  
    31.     shmdt(s);//断开映射
    32.  
    33.     exit(0);
    34.  
    35. }

    共享内存创建成功后，会一直存在，即使程序运行结束，也还会存在，除非删除此共享内存或者重启

     a.c文件持续写入，b.c文件持续读取

    a.c文件

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<unistd.h>
    4. #include<string.h>
    5. #include<sys/shm.h>
    6.  
    7. int main()
    8. {
    9.     //创建共享内存
    10.     int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);//key值为1234，共享内存大小为128，IPC_CREAT 存在则打开，不存在创建，权限0600
    11.     if(shmid==-1)
    12.     {
    13.         printf("shmget err\n");//创建失败
    14.         exit(1);
    15.     }
    16.  
    17.     //映射，将共享内存映射到进程的地址空间
    18.     //映射成功后就可以通过指针s访问此空间
    19.     char*s=(char*)shmat(shmid,NULL,0);//shmat本身返回值void*类型,强转为char*，shmid 共享内存id，给NULL。系统自动选择映射的虚拟地址空间标志位不指定为0
    20.     if(s==(char *)-1)
    21.     {
    22.         printf("shmat err\n");//映射失败
    23.         exit(1);
    24.     }
    25.  
    26.     while(1)
    27.     {
    28.         printf("input\n");
    29.         char buff[128]={0};//将输入的的数据放在buff中
    30.         fgets(buff,128,stdin);
    31.         strcpy(s,buff);//先将数据写入共享内存是为了也可以让读取数据时以end为结束标志
    32.         if(strncmp(buff,"end",3)==0)
    33.         {
    34.             break;//以end为输入结束的标志
    35.         }
    36.  
    37.     }
    38.     shmdt(s);//断开映射
    39.  
    40.     exit(0);
    41.  
    42. }
    43.                                                    
    44.

    b.c文件

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<unistd.h>
    4. #include<string.h>
    5. #include<sys/shm.h>
    6.  
    7. int main()
    8. {
    9.     //创建共享内存,存在就获取共享内存
    10.     int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);//key值为1234，共享内存大小为128，IPC_CREAT 存在则打开，不存在创建，权限0600
    11.     if(shmid==-1)
    12.     {
    13.         printf("shmget err\n");//创建失败
    14.         exit(1);
    15.     }
    16.  
    17.     //映射，将共享内存映射到进程的地址空间
    18.     //映射成功后就可以通过指针s访问此空间
    19.     char*s=(char*)shmat(shmid,NULL,0);//shmat本身返回值void*类型,强转为char*，shmid 共享内存id，给NULL。系统自动选择映射的虚拟地址空间 标
    20. 志位不指定为0
    21.     if(s==(char *)-1)
    22.     {
    23.         printf("shmat err\n");//映射失败
    24.         exit(1);
    25.     }
    26.  
    27.     while(1)
    28.     {
    29.         if(strncmp(s,"end",3)==0)
    30.         {
    31.             break;//先判断是不是结束标志，不是再输出
    32.         }
    33.         sleep(1);
    34.         printf("resf:%s\n",s);//以此读取数据
    35.     }   
    36.     
    37.  
    38.  
    39.  
    40.     shmdt(s);//断开映射
    41.  
    42.     exit(0);
    43.  
    44. }
    45.  
    46.

    运行结果如下：

     我们可以看到，b是可以读到共享内存的，a输入数据b可以读取，但是只要我们不输入新的数据，b就一直读取上一个数据，

    我们想要的结果是写一次，读一次，不写就不读，我们可以通过信号量解决这个问题

    使用信号量控制共享内存

    此时我们需要两个信号量，s1,s2

    sem.h

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<unistd.h>
    4. #include<string.h>
    5. #include<sys/sem.h>
    6.  
    7. #define SEM1 0 //第一个信号量
    8. #define SEM2 1 //第二个信号量
    9. #define NUM 2  //信号量总个数
    10.  
    11.  
    12. union semun
    13. {
    14.     int val;//初始值
    15. };//自己定义
    16.  
    17. void sem_init();//信号量初始化
    18. void sem_p(int index);//P操作,创建两个信号量，用下标区分
    19. void sem_v(int index);//V操作
    20. void sem_destroy();//销毁

    sem.c

    1. #include"sem.h"
    2.  
    3. static int semid = -1;//信号量id，只在本文件有效
    4.  
    5. void sem_init()//信号量初始化
    6. {
    7.     semid = semget((key_t)1234,NUM,IPC_CREAT|IPC_EXCL|0600);//key值为1234，SEM个信号量，全新创建一个信号量，如果已存在就报错，存取权限0600
    8.     if(semid == -1)//全新创建失败，说明已存在或者创建失败
    9.     {
    10.         semid=semget((key_t)1234,NUM,0600);
    11.         //semid = semget((key_t)1234,SEM,0600);//当信号已存在，获取信号量
    12.         if(semid == -1)
    13.         {
    14.             printf("semget err\n");//前面获取失败说明是创建的时候就失败了
    15.  
    16.         }
    17.     }
    18.     else//因为要创建NUM个信号量，循环初始化
    19.     {
    20.         union semun a;
    21.         int arr[NUM]={1,0};//信号量初始值数组
    22.         for(int i=0;i<NUM;i++)
    23.         {
    24.             a.val = arr[i];//信号量的初始值
    25.             if(semctl(semid,i,SETVAL,a)==-1)//i,信号量个数。SETVAL，a,赋初值
    26.             {
    27.                 printf("semctl init err\n");//初始化失败打印此语句
    28.             }
    29.         }
    30.  
    31.     }
    32.  
    33. }
    34.  
    35. void sem_p(int index)//P操作
    36. {
    37.  
    38.     if(index<0 || index>=NUM)
    39.     {
    40.         return;
    41.     }
    42.     struct sembuf buf;//对信号量的改变
    43.     buf.sem_num=index;//信号量的下标
    44.     buf.sem_op=-1;//对信号量执行的是p操作
    45.     buf.sem_flg = SEM_UNDO;//标志位，如果程序异常可以帮助进行v操作
    46.  
    47.     if(semop(semid,&buf,1)==-1)
    48.     {
    49.         printf("semop p err\n");
    50.     }
    51.  
    52. }
    53.  
    54. void sem_v(int index)//V操作
    55. {
    56.     if(index<0 || index>=NUM)
    57.     {
    58.         return;
    59.     }
    60.  
    61.     struct sembuf buf;//对信号量的改变
    62.     buf.sem_num=index;//信号量的下标
    63.     buf.sem_op=1;//对信号量执行的是v操作
    64.     buf.sem_flg = SEM_UNDO;
    65.  
    66.     if(semop(semid,&buf,1)==-1)
    67.     {
    68.         printf("semop v err\n");
    69.     }
    70.  
    71. }
    72.  
    73. void sem_destroy()//销毁
    74. {
    75.     if(semctl(semid,0,IPC_RMID)==-1)//semid 要删除的信号，0 占位，根据semid删除创建的所有信号。IPC_RMID 删除信号量
    76.     {
    77.         printf("semctl destroy err\n");
    78.     }
    79.  
    80. }
    81.  
    82.

    a.c

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<unistd.h>
    4. #include<string.h>
    5. #include<sys/shm.h>
    6. #include"sem.h"
    7.  
    8. int main()
    9. {
    10.     //创建共享内存
    11.     int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);//key值为1234，共享内存大小为128，IPC_CREAT 存在则打开，不存在创建，权限0600
    12.     if(shmid==-1)
    13.     {
    14.         printf("shmget err\n");//创建失败
    15.         exit(1);
    16.     }
    17.  
    18.     //映射，将共享内存映射到进程的地址空间
    19.     //映射成功后就可以通过指针s访问此空间
    20.     char*s=(char*)shmat(shmid,NULL,0);//shmat本身返回值void*类型,强转为char*，shmid 共享内存id，给NULL。系统自动选择映射的虚拟地址空间 标>
    21. 志位不指定为0
    22.     if(s==(char *)-1)
    23.     {
    24.         printf("shmat err\n");//映射失败
    25.         exit(1);
    26.     }
    27.  
    28.     sem_init();//信号量初始化
    29.     while(1)
    30.     {
    31.         printf("input\n");
    32.         char buff[128]={0};//将输入的的数据放在buff中
    33.         fgets(buff,128,stdin);
    34.         sem_p(SEM1);//对a文件先P操作
    35.         strcpy(s,buff);//先将数据写入共享内存是为了也可以让读取数据时以end为结束标志
    36.         sem_v(SEM2);//对b文件进行v操作，不能将v操作放在下面的判读之后，因为如果最后输出end结束后，b文件不能进行v操作获得权限就无法打印最后
    37. 一个
    38.         if(strncmp(buff,"end",3)==0)
    39.         {
    40.             break;//以end为输入结束的标志
    41.         }
    42.  
    43.     }
    44.  
    45.     shmdt(s);//断开映射
    46.  
    47.     exit(0);
    48.  
    49. }

    b.c文件

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<unistd.h>
    4. #include<string.h>
    5. #include<sys/shm.h>
    6. #include"sem.h"
    7.  
    8. int main()
    9. {
    10.     //创建共享内存,存在就获取共享内存
    11.     int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);//key值为1234，共享内存大小为128，IPC_CREAT 存在则打开，不存在创建，权限0600
    12.     if(shmid==-1)
    13.     {
    14.         printf("shmget err\n");//创建失败
    15.         exit(1);
    16.     }
    17.  
    18.     //映射，将共享内存映射到进程的地址空间
    19.     //映射成功后就可以通过指针s访问此空间
    20.     char*s=(char*)shmat(shmid,NULL,0);//shmat本身返回值void*类型,强转为char*，shmid 共享内存id，给NULL。系统自动选择映射的虚拟地址空间 标>
    21. 志位不指定为0
    22.     if(s==(char *)-1)
    23.     {
    24.         printf("shmat err\n");//映射失败
    25.         exit(1);
    26.     }
    27.  
    28.     sem_init();//初始化信号量
    29.     while(1)
    30.     {
    31.         sem_p(SEM2);
    32.         if(strncmp(s,"end",3)==0)
    33.         {
    34.             break;//先判断是不是结束标志，不是再输出
    35.         }
    36.         printf("resf:%s\n",s);//以此读取数据
    37.         sem_v(SEM1);
    38.     }
    39.  
    40.  
    41.     shmdt(s);//断开映射
    42.  
    43.     sem_destroy();//销毁信号量
    44.     exit(0);
    45.  
    46. }

    运行程序

    运行结果

  • 相关阅读:
    ChatGPT工作提效之使用python开发对接百度地图开放平台API的实战方案（批量路线规划、批量获取POI、突破数量有限制、批量地理编码）
    MySQL 如何避免克隆失败后再次初始化
    python提高运算速度的方法：内存缓存+磁盘缓存
    PDF转换成PPT后格式混乱,可能这个没做好
    第一个 vue-cli 项目
    基于K-prototype算法聚类
    webrtc gcc算法(1)
    03-安装docker及使用docker安装其他软件（手动挂载数据卷）
    pyhton将socket接收数据的字节改变并做处理
    信钰证券：长江电力180亿市值，招商证券、摩根大通等浮盈超一成
  • 原文地址：https://blog.csdn.net/swint_er/article/details/125360242