STM32/STM8技术论坛
直播中

donatello1996

8年用户 687经验值
擅长:处理器/DSP 控制/MCU RF/无线
私信 关注
[经验]

【100ASK_IMX6ULL(带屏) 开发板试用体验】基于shm共享内存的双进程全双工通信

`       上周刚学完unix socket，这周尝试一下Linux环境另一款非常好用/非常常用的进程间通信方式——共享内存，这个共享内存同样是需要入门Linux代码的小白熟练掌握的，跟unix socket一样非常常用。共享内存，顾名思义就是不同的进程访问同一块内存，这块内存的特点，一是使用前需要手动申请给用户层；二是用户程序（进程）结束之后如果不手动释放的话会一直被占用且一直可被访问（读/写），外部终端查看被使用共享内存可用
  1. ipcs -a

指令；三是这块内存若要不想出现访问冲突，需要手动加锁，不然的话被两个或多个进程同时改写，这个在实际项目中是不允许出现的，但是我还没学会怎么给共享内存加锁，现在这帖贴出的Demo先确保同一块共享内存不会被多个进程同时改写，用的思想还是跟上一帖socket的思想一样，两个进程的读和写用两块不同的共享内存实现，比如说进程A和进程B，共享内存A和共享内存B，共享内存A只能被进程A写， 被进程B读，共享内存B只能被进程B写，被进程A读；四是内存访问速度比socket快，用在效率要求高的场合项目；五是需要借助key文件进行shm地址的定位，以便确保进程A和进程B访问的共享内存地址（或shmid）是正确的，这个key文件可以是touch新建出来的文件，反正都会被进程改写；六是不同进程之间地位平等，不像socket那样分主进程和从进程，主进程gg从进程跟着gg，从这点看的话，共享内存不需要担心某个进程崩溃的问题，这是相对socket通信的优点。
33.jpg

      上代码，进程1：
  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8. #include
  9. #include

  11. key_t key1 , key2;
  12. int shmid1 , shmid2;
  13. char *p1 = NULL , *p2 = NULL;
  14. pthread_t id1;

  16. void *Thread_Send(void *arg)
  17. {
  18.     while(1)
  19.     {
  20.                 fgets(p2,10,stdin);
  21.         }
  22. }

  24. int main(int argc, const char *argv[])
  25. {

  27.     key1 = ftok("./app1",'b'); //获取唯一的 key 值,
  28.     if(key1 < 0)
  29.     {
  30.         perror("fail ftok ");
  31.         return -1;
  32.     }

  34.     shmid1 = shmget(key1, 128, IPC_CREAT|IPC_EXCL|0777);
  35.         //创建/打开共享内存，返回id根据id映射
  36.        
  37.     if(shmid1 < 0)
  38.     {
  39.         if(errno == EEXIST)
  40.                 //文件存在时，直接打开文件获取shmid
  41.         {
  42.             printf("file eexist");
  43.             shmid1 = shmget(key1,128,0777);
  44.         }
  45.         else
  46.         {
  47.             perror("shmget fail ");
  48.             return -2;
  49.         }
  50.     }
  51.     p1 = (char *)shmat(shmid1,NULL,0);
  52.         //映射，返回地址，根据地址操作
  53.     if( p1 == (char *)(-1) )
  54.     {
  55.         perror("shmat fail ");
  56.         return -3;
  57.     }

  59.         key2 = ftok("./app2",'b'); //获取唯一的 key 值,
  60.     if(key2 < 0)
  61.     {
  62.         perror("fail ftok ");
  63.         return -1;
  64.     }

  66.     shmid2 = shmget(key2, 128, IPC_CREAT|IPC_EXCL|0777);
  67.         //创建/打开共享内存，返回id根据id映射
  68.        
  69.     if(shmid2 < 0)
  70.     {
  71.         if(errno == EEXIST)
  72.                 //文件存在时，直接打开文件获取shmid
  73.         {
  74.             printf("file eexist");
  75.             shmid2 = shmget(key2,128,0777);
  76.         }
  77.         else
  78.         {
  79.             perror("shmget fail ");
  80.             return -2;
  81.         }
  82.     }
  83.     p2 = (char *)shmat(shmid2 , NULL , 0);
  84.         //映射，返回地址，根据地址操作
  85.     if(p2 == (char *)(-1) )
  86.     {
  87.         perror("shmat fail ");
  88.         return -3;
  89.     }
  90.         pthread_create(&id1,NULL,Thread_Send,NULL);
  91.     while(1)
  92.     {
  93.         sleep(1);
  94.         printf("P:%s
  95. ",p1);
  96.     }
  97.     shmdt(p1);
  98.         //解除映射
  99.        
  100.     shmctl(shmid1,IPC_RMID,NULL);
  101.         //删除
  102.     return 0;
  103. }


      上代码，进程2：
  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8. #include
  9. #include

  11. key_t key1 , key2;
  12. int shmid1 , shmid2;
  13. char *p1 = NULL , *p2 = NULL;
  14. pthread_t id1;

  16. void *Thread_Send(void *arg)
  17. {
  18.     while(1)
  19.     {
  20.                 fgets(p1,10,stdin);
  21.         }
  22. }

  24. int main(int argc, const char *argv[])
  25. {

  27.     key1 = ftok("./app1",'b');
  28.     if(key1 < 0)
  29.     {
  30.         perror("fail ftok ");
  31.         exit(1);
  32.     }
  33.     shmid1 = shmget(key1,128,IPC_CREAT|IPC_EXCL|0777);//创建/打开共享内存，返回id根据id映射
  34.     if(shmid1 < 0)
  35.     {
  36.         if(errno == EEXIST)
  37.         {
  38.             printf("file eexist");
  39.             shmid1 = shmget(key1,128,0777);
  40.         }
  41.         else
  42.         {
  43.             perror("shmget fail ");
  44.             exit(1);
  45.         }
  46.     }
  47.     p1 = (char *)shmat(shmid1,NULL,0);//映射，返回地址，根据地址操作
  48.     if( p1 == (char *)(-1) )
  49.     {
  50.         perror("shmat fail ");
  51.         exit(1);
  52.     }

  54.         key2 = ftok("./app2",'b'); //创建key值,
  55.     if(key2 < 0)
  56.     {
  57.         perror("fail ftok ");
  58.         exit(1);
  59.     }
  60.     shmid2 = shmget(key2,128,IPC_CREAT|IPC_EXCL|0777);//创建/打开共享内存，返回id根据id映射
  61.     if(shmid2 < 0)
  62.     {
  63.         if(errno == EEXIST)//文件存在时，直接打开文件获取shmid
  64.         {
  65.             printf("file eexist");
  66.             shmid2 = shmget(key2,128,0777); //共享内存存在时，直接打开
  67.         }
  68.         else
  69.         {
  70.             perror("shmget fail ");
  71.             exit(1);
  72.         }
  73.     }
  74.     p2 = (char *)shmat(shmid2,NULL,0);//映射，返回地址，根据地址操作
  75.     if( p2 == (char *)(-1) )
  76.     {
  77.         perror("shmat fail ");
  78.         exit(1);
  79.     }
  80.         pthread_create(&id1,NULL,Thread_Send,NULL);
  81.     while(1)
  82.     {
  83.         sleep(1);
  84.         printf("P:%s
  85. ",p2);
  86.     }
  87.     shmdt(p1);
  88.         //解除映射

  90.     //函数原型 int shmctl(int shmid, int cmd, struct shmid_ds *buf);
  91.     shmctl(shmid1,IPC_RMID,NULL); //删除
  92.     return 0;
  93. }




无论是先运行进程1还是进程2，都需要先在文件夹内创建key文件app1和app2，以便定位共享内存shmid：
  1. touch app1
  2. touch app2
34.jpg


运行效果：
36.jpg

从终端看不出fgets输入和打印输出的区别，不过两个进程读写通信是没有任何问题的。
` 35.jpg

更多回帖

0 0 0

相关帖子

开发板试用 全双工通信
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分