linux--共享内存函数（shmget、shmat、shmdt、shmctl）及其范例

最新推荐文章于 2023-06-03 09:32:38 发布

worthsen

最新推荐文章于 2023-06-03 09:32:38 发布

阅读量3.9k

点赞数 6

分类专栏： Linux Linux 进阶

本文链接：https://blog.csdn.net/qq_38880380/article/details/79444713

版权

Linux 同时被 2 个专栏收录

122 篇文章 12 订阅

订阅专栏

Linux 进阶

39 篇文章 3 订阅

订阅专栏

一、共享内存的介绍

共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。

二、共享内存的特点

1、共享内存是进程间共享数据的一种最快的方法。一个进程向共享的内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。

2、使用共享内存要注意的是多个进程之间对一个给定存储区访问的互斥。若一个进程正在向共享内存区写数据，则在它做完这一步操作前，别的进程不应当去读、写这些数据。

三、共享内存函数介绍

1、shmget函数原型

shmget(得到一个共享内存标识符或创建一个共享内存对象)
所需头文件	#include <sys/ipc.h> #include <sys/shm.h>
函数说明	得到一个共享内存标识符或创建一个共享内存对象并返回共享内存标识符
函数原型	int shmget(key_t key, size_t size, int shmflg)
函数传入值	key	0(IPC_PRIVATE)：会建立新共享内存对象
		大于0的32位整数：视参数shmflg来确定操作。通常要求此值来源于ftok返回的IPC键值
	size	大于0的整数：新建的共享内存大小，以字节为单位
		0：只获取共享内存时指定为0
	shmflg	0：取共享内存标识符，若不存在则函数会报错
		IPC_CREAT：当shmflg&IPC_CREAT为真时，如果内核中不存在键值与key相等的共享内存，则新建一个共享内存；如果存在这样的共享内存，返回此共享内存的标识符
		IPC_CREAT\|IPC_EXCL：如果内核中不存在键值与key相等的共享内存，则新建一个消息队列；如果存在这样的共享内存则报错
函数返回值	成功：返回共享内存的标识符
	出错：-1，错误原因存于error中
附加说明	上述shmflg参数为模式标志参数，使用时需要与IPC对象存取权限（如0600）进行\|运算来确定信号量集的存取权限
错误代码	EINVAL：参数size小于SHMMIN或大于SHMMAX EEXIST：预建立key所指的共享内存，但已经存在 EIDRM：参数key所指的共享内存已经删除 ENOSPC：超过了系统允许建立的共享内存的最大值(SHMALL) ENOENT：参数key所指的共享内存不存在，而参数shmflg未设IPC_CREAT位 EACCES：没有权限 ENOMEM：核心内存不足

2、shmat函数原型

shmat(把共享内存区对象映射到调用进程的地址空间)
所需头文件	#include <sys/types.h> #include <sys/shm.h>
函数说明	连接共享内存标识符为shmid的共享内存，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问
函数原型	void shmat(int shmid, const void shmaddr, int shmflg)
函数传入值	msqid	共享内存标识符
	shmaddr	指定共享内存出现在进程内存地址的什么位置，直接指定为NULL让内核自己决定一个合适的地址位置
	shmflg	SHM_RDONLY：为只读模式，其他为读写模式
函数返回值	成功：附加好的共享内存地址
	出错：-1，错误原因存于error中
附加说明	fork后子进程继承已连接的共享内存地址。exec后该子进程与已连接的共享内存地址自动脱离(detach)。进程结束后，已连接的共享内存地址会自动脱离(detach)
错误代码	EACCES：无权限以指定方式连接共享内存 EINVAL：无效的参数shmid或shmaddr ENOMEM：核心内存不足

3、shmdt函数原型

shmat(断开共享内存连接)
所需头文件	#include <sys/types.h> #include <sys/shm.h>
函数说明	与shmat函数相反，是用来断开与共享内存附加点的地址，禁止本进程访问此片共享内存
函数原型	int shmdt(const void *shmaddr)
函数传入值	shmaddr：连接的共享内存的起始地址
函数返回值	成功：0
函数返回值	出错：-1，错误原因存于error中
附加说明	本函数调用并不删除所指定的共享内存区，而只是将先前用shmat函数连接（attach）好的共享内存脱离（detach）目前的进程
错误代码	EINVAL：无效的参数shmaddr

4、shmctl函数原型

shmctl(共享内存管理)
所需头文件	#include <sys/types.h> #include <sys/shm.h>
函数说明	完成对共享内存的控制
函数原型	int shmctl(int shmid, int cmd, struct shmid_ds *buf)
函数传入值	msqid	共享内存标识符
	cmd	IPC_STAT：得到共享内存的状态，把共享内存的shmid_ds结构复制到buf中
		IPC_SET：改变共享内存的状态，把buf所指的shmid_ds结构中的uid、gid、mode复制到共享内存的shmid_ds结构内
		IPC_RMID：删除这片共享内存
	buf	共享内存管理结构体。具体说明参见共享内存内核结构定义部分
函数返回值	成功：0
	出错：-1，错误原因存于error中
错误代码	EACCESS：参数cmd为IPC_STAT，确无权限读取该共享内存 EFAULT：参数buf指向无效的内存地址 EIDRM：标识符为msqid的共享内存已被删除 EINVAL：无效的参数cmd或shmid EPERM：参数cmd为IPC_SET或IPC_RMID，却无足够的权限执行

四、父子进程通信范例

父子进程通信范例，shm.c源代码如下：

//
#include <stdio.h>  
#include <unistd.h>  
#include <string.h>  
#include <sys/ipc.h>  
#include <sys/shm.h>  
#include <error.h>  
#define SIZE 1024  
  
int main()  
{  
    int shmid ;  
    char *shmaddr ;  
    struct shmid_ds buf ;  
    int flag = 0 ;  
    int pid ;   
  
    shmid = shmget(IPC_PRIVATE, SIZE, IPC_CREAT|0600 ) ;  
  
    if ( shmid < 0 )  
    {  
            perror("get shm  ipc_id error") ;  
            return -1 ;  
    }  
  
    pid = fork() ;  
    if ( pid == 0 )  
    {  
        shmaddr = (char *)shmat( shmid, NULL, 0 ) ;  
        if ( (int)shmaddr == -1 )  
        {  
            perror("shmat addr error") ;  
            return -1 ;  
        }  
        strcpy( shmaddr, "Hi, I am child process!\n") ;  
        shmdt( shmaddr ) ;  
        return  0;  
    } else if ( pid > 0) {  
        sleep(3 ) ;  
        flag = shmctl( shmid, IPC_STAT, &buf) ;  
        if ( flag == -1 )  
        {  
            perror("shmctl shm error") ;  
            return -1 ;  
        }   
  
        printf("shm_segsz =%d bytes\n", buf.shm_segsz ) ;  
        printf("parent pid=%d, shm_cpid = %d \n", getpid(), buf.shm_cpid ) ;  
        printf("chlid pid=%d, shm_lpid = %d \n",pid , buf.shm_lpid ) ;  
        shmaddr = (char *) shmat(shmid, NULL, 0 ) ;  
  
        if ( (int)shmaddr == -1 )  
        {  
            perror("shmat addr error") ;  
            return -1 ;  
        }  
        printf("%s", shmaddr) ;  
        shmdt( shmaddr ) ;  
        shmctl(shmid, IPC_RMID, NULL) ;  
    }else{  
        perror("fork error") ;  
        shmctl(shmid, IPC_RMID, NULL) ;  
    }  
    return 0 ;  
}  
//

//
编译 gcc shm.c –o shm。  
执行 ./shm，执行结果如下：  
shm_segsz =1024 bytes  
shm_cpid = 9503  
shm_lpid = 9504  
Hi, I am child process!  
//

五、多进程读写范例

多进程读写即一个进程写共享内存，一个或多个进程读共享内存。下面的例子实现的是一个进程写共享内存，一个进程读共享内存。

（1）下面程序实现了创建共享内存，并写入消息。

shmweite.c源代码如下：

//  
#include <stdio.h>  
#include <sys/ipc.h>  
#include <sys/shm.h>  
#include <sys/types.h>  
#include <unistd.h>  
#include <string.h>  
  
typedef struct{  
    char name[8];  
    int age;  
} people;  
  
int main(int argc, char** argv)  
{  
    int shm_id,i;  
    key_t key;  
    char temp[8];  
    people *p_map;  
    char pathname[30] ;  
   
    strcpy(pathname,"/tmp") ;  
    key = ftok(pathname,0x03);  
    if(key==-1)  
    {  
        perror("ftok error");  
        return -1;  
    }  
    printf("key=%d\n",key) ;  
    shm_id=shmget(key,4096,IPC_CREAT|IPC_EXCL|0600);   
   
    if(shm_id==-1)  
    {  
        perror("shmget error");  
        return -1;  
    }  
    printf("shm_id=%d\n", shm_id) ;  
    p_map=(people*)shmat(shm_id,NULL,0);  
    memset(temp, 0x00, sizeof(temp)) ;  
    strcpy(temp,"test") ;  
    temp[4]='0';  
   
    for(i = 0;i<3;i++)  
    {  
        temp[4]+=1;  
        strncpy((p_map+i)->name,temp,5);  
        (p_map+i)->age=0+i;  
    }  
    shmdt(p_map) ;  
    return 0 ;  
}  
//

（2）下面程序实现从共享内存读消息。

shmread.c源代码如下：

//  
#include <stdio.h>  
#include <string.h>  
#include <sys/ipc.h>  
#include <sys/shm.h>  
#include <sys/types.h>  
#include <unistd.h>  
  
typedef struct{  
    char name[8];  
    int age;  
} people;  
  
int main(int argc, char** argv)  
{  
    int shm_id,i;  
    key_t key;  
    people *p_map;  
    char pathname[30] ;  
  
    strcpy(pathname,"/tmp") ;  
    key = ftok(pathname,0x03);  
    if(key == -1)  
    {  
        perror("ftok error");  
        return -1;  
    }  
    printf("key=%d\n", key) ;  
    shm_id = shmget(key,0, 0);     
    if(shm_id == -1)  
    {  
        perror("shmget error");  
        return -1;  
    }  
    printf("shm_id=%d\n", shm_id) ;  
    p_map = (people*)shmat(shm_id,NULL,0);  
    for(i = 0;i<3;i++)  
    {  
        printf( "name:%s\n",(*(p_map+i)).name );  
        printf( "age %d\n",(*(p_map+i)).age );  
    }  
    if(shmdt(p_map) == -1)  
    {  
        perror("detach error");  
        return -1;  
    }  
    return 0 ;  
}  
//

（3）编写与执行

//
1、    编译gcc shmwrite.c -o  shmwrite。  
2、    执行./shmwrite，执行结果如下：  
key=50453281  
shm_id=688137  
3、    编译gcc shmread.c -o shmread。  
4、    执行./shmread，执行结果如下：  
key=50453281  
shm_id=688137  
name:test1  
age 0  
name:test2  
age 1  
name:test3  
age 2  
5、    再执行./shmwrite，执行结果如下：  
key=50453281  
shmget error: File exists  
6、    使用ipcrm -m 688137删除此共享存。  
//

六、linux下使用Qt 创建多进程共享内存的范例

1、定义共享内存头文件

//
vi share_memory.h
//

2、在头文件中定义共享数据结构体

//
//******************************************************************************************************
// File Name: share_memory.h
// File Description: The head file for share memory 
// Author:  Sen
// Date: 2018-01-10
//******************************************************************************************************
#ifndef _SHARE_MEMORY_H
#define _SHARE_MEMORY_H

#define        SHM_SEED 10240

typedef struct{  
    int camera_info;				//0 驱动失败 1 驱动成功 
    float speed;					//小车速度：km/h
} camera_shm; 

#endif
//

3、shmwrite工程（Qt）

（1）工程中加入share_memory.h头文件

（2）自己定义的widget类对应的头文件中加入如下代码（共享内存需要的头文件和自己定义的share_memory.h）

//
#include "share_memory.h"
#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
//

（3）定义widget类中的一成员函数 shmwrite()，函数体如下

//
    int shm_id;
    camera_shm *shm;

     /*get share memory id from key value(SHM_SEED)*/
    shm_id = shmget((key_t)SHM_SEED, sizeof(camera_shm), 0666|IPC_CREAT);

    if(shm_id == -1)
    {
        perror("shmget error");
        return -1;
    }
    printf("shm_id=%d\n", shm_id);
    shm = (camera_shm *)shmat(shm_id, 0, 0);

    (*shm).camera_info = 1;
    (*shm).speed = 10;
    //如果不断写入共享内存变量值，就不要调用shmdt()函数断开
    if(shmdt(shm) == -1)
    {
        perror("detach error");
        return -1;
    }
//

（4）main函数中调用widget类中的成员函数shmwrite()就行

4、shmread工程（Qt）

（1）工程中加入share_memory.h头文件

（2）自己定义的widget类对应的头文件中加入如下代码（共享内存需要的头文件和自己定义的share_memory.h）

//
#include "share_memory.h"
#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
//

（3）定义widget类中的一成员函数 shmread()，函数体如下

//
    int shm_id;
    camera_shm *shm;

     /*get share memory id from key value(SHM_SEED)*/
    shm_id = shmget((key_t)SHM_SEED, sizeof(camera_shm), 0666|IPC_CREAT);

    if(shm_id == -1)
    {
        perror("shmget error");
        return -1;
    }
    printf("shm_id=%d\n", shm_id);
    shm = (camera_shm *)shmat(shm_id, 0, 0);

    printf("camera_shm.speed:%f\n",(*shm).speed);
    printf("camera_shm.camera_info:%d\n",(*shm).camera_info );

    if(shmdt(shm) == -1)
    {
        perror("detach error");
        return -1;
    }
//

（4）main函数中调用widget类中的成员函数shmread()就行

致谢

1、共享内存函数（shmget、shmat、shmdt、shmctl）及其范例

2、共享内存

3、【IPC通信】key_t键和ftok函数

4、《深入浅出Linux工具与编程》

5、Linux进程间通信（六）：共享内存 shmget()、shmat()、shmdt()、shmctl()

worthsen

关注

6
点赞
踩
47

收藏

觉得还不错? 一键收藏
打赏
2
评论
linux--共享内存函数（shmget、shmat、shmdt、shmctl）及其范例

一、共享内存的介绍共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。二、共享内存的特点1、共享内存是进程间共享数据的一种最快的方法。一个进程向共享的内存区域写入了数据，共享这个内存区域的所有进程就可以立...
复制链接

扫一扫