Linux9：内存映射，键值含义，共享内存，消息队列，信号量

旧城等待， 2022-12-15 14:06 128阅读 0赞

## 内存映射，键值含义，共享内存，消息队列，信号量 ##

**1.内存映射：**

**概念：**  
系统在调用进程的虚拟地址空间创建一个新内存映射

**文件映射：**  
将文件映射到进程空间得到一个可操作的地址，  
对地址操作就是对文件直接读写

**属性：**

> 私有映射  
> MAP\_PRIVATE  
> 在映射内容上发生的变化对其他进程不可见  
> 对文件映射来说不会影响底层文件  
> 共享映射  
> MAP\_SHARED  
> 在映射内容上发生的变化对其他进程可见  
> 对文件映射来说会影响底层文件

**映射mmap:**

> 功能  
> 内存映射函数mmap, 负责把文件内容映射到进程的虚拟内存空间, 通过对这段内存的读取和修改，来实现对文件的读取和修改,而不需要再调用read，write等操作。  
> 原型  
> void \*mmap(void \*start, size\_t length, int prot, int flags,int fd, off\_t offset);  
> 参数  
> start：指定映射到进程空间的地址，指定为NULL表示系统自动分配  
> length：指定映射的文件长度，单位是 以字节为单位，不足一内存页按一内存页处理  
> prot：期待获取的操作，需要两个权限的可以用或|  
> PROT\_EXEC映射区可被执行  
> PROT\_READ映射区可被读取  
> PROT\_WRITE映射区可被写入  
> PROT\_NONE映射区不可访问  
> flags标志  
> MAP\_SHARED对此区域所做的修改内容将写入文件内；允许其他映射该文件的进程共享  
> MAP\_PRIVATE:对此区域所做的修改不会更改原来的文件内容，对映射区的写入操作会产生一个映射区的复制  
> fd文件描述符要映射的文件  
> offset：文件起始偏移量  
> 设置为0  
> 返回值  
> 成功返回映射成功后的地址  
> 失败返回-1  
> 注意  
> 权限

**解除munmap:**

> 原型:  
> int munmap(void \*start, size\_t length);  
> 解除映射操作

**内存操作函数:**

> 操作一个内存块  
> memcpy  
> 内存拷贝函数  
> void \*memcpy(void \*dest, const void \*src, size\_t n);  
> 目标地址  
> 源地址  
> 复制内容大小  
> 返回一个指向dest的指针  
> memcpy(p,“hello”,6);  
> write();  
> memset  
> 对一个内存块进行整体的赋值常用清空内存块  
> memset(char \*p,int num,int size);  
> 内存中某个首地址  
> 需要赋的值  
> 需要赋的字节数大小 （memset（a，0，sizeof（a）））：清零  
> memset(p,0,10);

注意:  
只能对已有的文件内容做修改:

代码演示：

#include <stdio.h>
    #include <unistd.h>
    #include <sys/mman.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <string.h>
    int main()
    {
        
     int fd = open("./demo1.c",O_RDWR);//不能打开时新建，因为新文件大小为0
     //int fd = open("./demo1.c",O_RDWR|O_CREAT,0777);
     int len= lseek(fd,0,SEEK_END);
     char *p=mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,0);
     //char *p=mmap(NULL,len,PROT_WRITE,MAP_PRIVATE,fd,0);//映射大小不能为0
     if(p==(char *)-1)
     {
        
      perror("mmap");
      return 0;
     }
     memcpy(p,"hell0 world",12);//覆盖前12字节
     //memset(p,'1',20);//写入时：是将整形转化为 char
     //strcpy(p,"hello");
     //printf("%s\n",p);//%s遇/0结束
     //printf("%s\n",p+12);
     return 0;
    }

说明：

char *p=mmap(NULL,len,PROT_WRITE,MAP_SHARED,fd,0);
     char *p=mmap(NULL,len,PROT_WRITE,MAP_PRIVATE,fd,0);//映射大小不能为0

1.共享映射可以改变，私有映射无法改变(但能够打印出来)，并且映射的内容大小不能为0；

2.必须对已有的文件进行映射，且已有文件大小>0，映射内容的大小可以超过文件的大小，不能打开时候新建，因为新建文件大小为0，会映射失败。

int fd = open("./demo1.c",O_RDWR|O_CREAT,0777);
    //错误

3.memset：写入时：将整型转化为 char(0不需要)

memset(p,'1',20);

**2.键值含义：**

**定义：**  
用于标识共享内存、消息队列以及信号量集  
保证进程打开的共享内存、消息队列、信号量集是同一个

**获取键值：**

> ftok  
> 功能  
> 获取键值  
> 原型  
> key\_t ftok(const char \*pathname, int proj\_id);  
> 所属头文件  
> \# include <sys/types.h>  
> \# include <sys/ipc.h>  
> 参数  
> pathname就时你指定的文件名(该文件必须是存在而且可以访问的)  
> proj\_id是子序号，虽然为int，但是只有8个比特被使用(0-255)  
> 返回值  
> 当成功执行的时候，一个key\_t值将会被返回，否则 -1 被返回

**3.共享内存：**

**指令：**

ipcs -m   //看Shared Memory 共享内存
     ipcs -s   //看Semaphore Arrays 信号量
     ipcs -q   //看Message Queues 消息队列

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center]

**定义：**  
在操作系统内核开辟一个空间，每一个进程都可以将这个空间映射到自己的进程空间里面，多个进程可以共享这块内存，对他的操作都可以立即实现。

**过程：**

> 创建共享内存  
> 进程1映射内存进行读写  
> 进程2映射共享内存进行读写  
> 进程1、进程2 解除映射  
> 删除共享内存

**相关API：**

创建：

> 功能  
> 用来获得共享内存区域的ID，如果不存在指定的共享区域就创建相应的区域  
> 原型  
> int shmget(key\_t key, size\_t size, int shmflg);  
> 头文件  
> \#include <sys/types.h>  
> \#include <sys/ipc.h>  
> \#include <sys/shm.h>  
> 参数  
> key：键值  
> IPC\_PRIVATE//键值为0 表示创建的共享内存只能父子间用  
> ftok()//任意进程都可以用  
> size：大小  
> shmflg：标志(IPC\_CREAT没有就创建)同 open 函数的权限位，也可以用八进制表示法  
> 返回值  
> 成功返回内存段标识符，失败-1

映射:

> 功能  
> 把共享内存区域映射到调用进程的地址空间中去  
> 原型  
> void \*shmat(int shmid, const void \*shmaddr, int shmflg);  
> 头文件  
> \#include <sys/types.h>  
> \#include <sys/ipc.h>  
> \#include <sys/shm.h>  
> 参数  
> shmid要映射的共享内存区标识符  
> shmaddr：将共享内存映射到指定位置（若为 0 则表示把该段共享内存映射到调用进程的地址空间  
> shmflg：默认 0：共享内存可读写  
> SHM\_RDONLY：共享内存只读  
> 返回值  
> 成功：被映射的段地址，失败返回-1

解除:

> 功能  
> 调用用来解除进程对共享内存区域的映射  
> 原型  
> int shmdt(const void \*shmaddr);  
> 头文件  
> \#include <sys/types.h>  
> \#include <sys/ipc.h>  
> \#include <sys/shm.h>  
> 参数  
> 被映射的共享内存段地址  
> 返回值  
> 成功返回0失败返回-1

设置:  
原型

> int shmctl(int shmid, int cmd, struct shmid\_ds \*buf);  
> 参数  
> shmid  
> shmget的返回值  
> cmd  
> 选择的操作  
> IPC\_STAT：获取共享内存属性  
> IPC\_SET：修改共享内存  
> IPC\_RMID：删除共享内存，此时第三个参数为NULL  
> buf

//获取共享内存属性
    structshmid_ds*buf=malloc(sizeof(structshmid_ds));
    structshmid_dsbuf;
    shmctl(shm,IPC_STAT,&buf);

演示案例：创建共享内存，供父子之间进行使用：

演示代码：

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <string.h>
    #include <unistd.h>
    #include <sys/wait.h>
    int main()
    {
        
     char *p =NULL;
     char buf[100] = "IPC shmred memory";
     //1.获取共享内存标识  或者 创建
     int shm=shmget(IPC_PRIVATE,200,IPC_CREAT);//IPC_PRIVATE//键值为0 表示创建的共享内存只能父子间用
     printf("shm=%d\n",shm);
     if(shm==-1)
     {
        
      perror("shmget");
      return -1;
     }
     pid_t pid = fork();
     if(pid==0)
     {
            //将共享内存映射到进程里面
      p=shmat(shm,NULL,0);//0--可以对共享内存可读可写
      memset(p,0,200);//清理空间
      memcpy(p,buf,strlen(buf));
      //getchar();//等待输入一个字符
      //shmdt(p);//解除共享内存
     }
     else
     {
        
     //getchar();//等待输入一个字符
      //shmdt(p);//解除共享内存
      p = shmat(shm,NULL,0);//0--可以对共享内存可读可写
      wait(NULL);
      printf("father： %s\n",p);
    
    //sleep(5);
    //shmctl(shm,IPC_RMID,0);//删除共享内存
    
     }
     return 0;
    }

![在这里插入图片描述][20201017155940307.png_pic_center]  
注意：  
需要在管理员权限下运行程序。

查看shmdt解除映射的效果和shmctl删除共享内存的效果，可以通过 ：

ipcs -m

查看。

**案例演示2：**  
非亲缘关系之间的共享内存进行通信：

演示代码：  
写操作：

#include <sys/ipc.h>
    #include <sys/shm.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    //int shmget(key_t key, size_t size, int shmflg);
    int main()
    {
        
    int shmid;
    char *shmaddr;
    key_t key;
    key=ftok(".",1);//获取键值--内核位置
    shmid=shmget(key,1024*4,IPC_CREAT|0666);//共响内存以兆为单位，关键字：创造
    if(shmid==-1)
    {
        
    printf("创建共响内存失败\n");
    exit(-1);//通常设定，异常返回-1,正常返回0
    }
    // void *shmat(int shmid, const void *shmaddr, int shmflg);
    shmaddr=shmat(shmid,0,0);//连接共响内存，shmflg：0：代表映射进来的共响内存可读可写,,完成共项内存的映射
    printf("连接成功\n");
    strcpy(shmaddr,"liujinhui");//写入内容
    sleep(5);//写完后睡5s，让别的程序读走
    //int shmdt(const void *shmaddr);
    shmdt(shmaddr);//断开连接
    //int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    shmctl(shmid,IPC_RMID,0);//关闭共响内存/删除
    printf("退出\n");
    return 0;
    }

读操作：

#include <sys/ipc.h>
    #include <sys/shm.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    //int shmget(key_t key, size_t size, int shmflg);
    int main()
    {
        
    int shmid;
    char *shmaddr;
    key_t key;
    key=ftok(".",1);//获取键值--内核位置
    shmid=shmget(key,1024*4,0);//共响内存以兆为单位，关键字：不创造
    if(shmid==-1)
    {
        
    printf("创建共响内存失败\n");
    exit(-1);//通常设定，异常返回-1,正常返回0
    }
    // void *shmat(int shmid, const void *shmaddr, int shmflg);
    shmaddr=shmat(shmid,0,0);//连接共响内存，shmflg：0：代表映射进来的共响内存可读可写,,完成共项内存的映射
    printf("连接成功\n");
    printf("data:%s\n",shmaddr);//读出内容 
    //int shmdt(const void *shmaddr);
    shmdt(shmaddr);//断开连接
    printf("退出\n");
    return 0;
    }

运行结果：  
![在这里插入图片描述][20201017163718994.png_pic_center]

注意：在./write之后5s内操作./read

**4.消息队列：**

**4.1：消息队列的概念：**

消息队列就是一个消息的队列。可以把消息看作一个记录，具有特定的格式以及特定的优先级。对消息队列有写权限的进程可以向其中按照一定的规则添加新消息；对消息队列有读权限的进程则可以  
从消息队列中读走消息。

**4.2：消息队列使用流程：**

> 获取键值  
> 创建或者访问一个消息队列  
> 向队列读/写消息  
> 销毁队列

**4.3:消息队列相关API：**

**创建或打开：**  
功能：  
建新消息队列或取得已存在消息队列  
原型：

int msgget(key_t key, int msgflg);

所属头文件：  
\#include <sys / types.h>  
\#include <sys / ipc.h>  
\#include <sys / msg.h>  
参数：

> key：可以认为是一个端口号，也可以由函数ftok生成。  
> IPC\_PRIVATE：只能父子进程使用；  
> 非0值–自己指定或者ftok获取—任意进程使用；  
> msgflg：  
> IPC\_CREAT值，若没有该队列，则创建一个并返回新标识符；若已存在，则返回原标识符。  
> IPC\_EXCL值，若没有该队列，则返回-1；若已存在，则返回0。  
> IPC\_NOWAIT读写消息队列要求不满足不会阻塞。

返回值：  
成功执行时，返回消息队列标识值。失败返回-1，  
标识供发送，接收，删除使用

**添加消息队列:**  
功能:  
把消息添加到已打开的消息队列末尾  
原型:

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

所属头文件  
\#include <sys / types.h>  
\#include <sys / ipc.h>  
\#include <sys / msg.h>  
参数:

> msgid： 指明消息队列的 ID， 通常是 msgget 函数成功的返回值  
> msgp：发送数据缓冲区首地址  
> msgp：指向消息结构的指针。该消息结构 msgbuf 为：  
> struct msgbuf\{  
> long mtype;//消息类型----必须是long类型  
> char mtext\[1\];//消息正文  
> \}—需要自己定义  
> msgsz：数据大小，每个消息体最大不要超过 4K  
> msgflg:一般赋0，阻塞方式  
> IPC\_NOWAIT 若消息并没有立即发送而调用进程会立即返回

返回值:  
成功则返回0, 出错则返回-1

**读取消息:**  
功能:  
把消息从消息队列中取走，与 **FIFO 不同**的是，这里可以指定取走某一条消息  
原型:

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

所属头文件:  
\#include <sys / types.h>  
\#include <sys / ipc.h>  
\#include <sys / msg.h>  
参数:

> msqid：消息队列的队列 ID  
> msgp：消息缓冲区  
> size：消息的字节数，不要以 null 结尾  
> msgtyp：消息类型 =0 忽略类型 >0 只接收指定类型的数据  
> <0 只接受小于等于其绝对值的数据  
> 接收的类型为0  
> 默认接收当前消息队列第一条数据  
> 接收类型>0  
> 接收指定类型的第一条，如果没有，阻塞（需要参考flag）  
> 接收类型小于0  
> 接收小于等于该类型绝对值的最小类型的第一条消息  
> MSG\_NOERROR：若返回的消息比 size 字节多，则消息就会截短到size 字节，且不通知消息发送进程  
> IPC\_NOWAIT :若消息并没有立即接收而调用进程会立即返回  
> 函数传入值.  
> 0：msgrcv调用阻塞直到条件满足为止

返回值:  
接收成功返回0，失败返回-1

**控制消息队列:**  
功能:  
控制消息队列使用  
原型:

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

所属头文件:  
\#include <sys / types.h>  
\#include <sys / ipc.h>  
\#include <sys / msg.h>  
参数

> msqid：消息队列的队列 ID  
> cmd:  
> IPC\_STAT：读取消息队列的数据结构 msqid\_ds，并将其存储在buf 指定的地址中  
> IPC\_SET：设置消息队列的数据结构 msqid\_ds 中的 ipc\_perm 元素的值。这个值取自 buf 参数  
> IPC\_RMID：从系统内核中移走消息队列  
> Buf：消息队列缓冲区

返回值:  
接收成功返回0，失败返回-1

**案例演示：**  
建立消息队列，一段负责写入，一段负责读取。

write.c

#include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    #include <unistd.h>
    #include <string.h>
    #include <sys/types.h>
    struct Msg
    {
        
     long mtype;
     char mtext[100];
    };
    int main()
    {
        
     struct Msg w_buf;
     //创建/获取消息队列标识符
     int msg = msgget(12,IPC_CREAT);
     printf("msg = %d\n",msg);
     while(1)
     {
        
      memset(&w_buf,0,sizeof(w_buf));
      printf("请输入消息类型：");
      scanf("%ld",&w_buf.mtype);
      printf("请输入消息内容:");
      scanf("%s",w_buf.mtext);
      msgsnd(msg,&w_buf,sizeof(w_buf),0);
      perror("msgsnd");
     }
    // msgctl(msg,IPC_RMID,NULL);//从内核中删除消息队列
     return 0;
    }

read.c

#include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    #include <unistd.h>
    #include <string.h>
    #include <sys/types.h>
    struct Msg
    {
        
     long mtype;
     char mtext[100];//非循环发送消息时，读空间应大于写，不然会段错误
    };
    int main()
    {
        
     struct Msg r_buf;
     long type;
     int ret;
     //创建/获取消息队列标识符
     int msg = msgget(12,IPC_CREAT);
     printf("msg = %d\n",msg);
     while(1)
     {
        
      memset(&r_buf,0,sizeof(r_buf));
      printf("请输入读取消息的类型：");
      scanf("%ld",&r_buf.mtype); 
      ret = msgrcv(msg,&r_buf,sizeof(r_buf),r_buf.mtype,0);
      perror("msgrcv");
      printf("ret = %d\n",ret);
      printf("read: %ld\t%s\n",r_buf.mtype,r_buf.mtext);
     }
     return 0;
    }

运行结果：  
。。。

**5.信号量：**

**5.1：信号量的定义：**

信号量是多进程/多线程同步的一种方式，可以实现对共享资源的保护--------资源允许操作的最大数目

**5.2：信号量工作原理：**

对共享资源访问保护：

> 1） 初始化信号量值为 1  
> 2） 获得信号量 — 》 把信号值-1 —》 变成 0  
> 3） 操作要保护的代码  
> 4） 释放信号量 —》 把信号值+1

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 1]  
原理:

访问临界资源的代码叫做临界区，临界区本身也会称为临界资源.  
硬件资源（处理器、内存、存储器及其它外围设备等）和软件资源（共享代码段、共享结构和变量等）

> P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行  
> V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1

**5.3:信号量使用流程：**

> 1） 创建信号集。  
> 信号集： 一个信号量变量是一个信号量，多个信号量就是组成一个集合,类似数组。  
> 2）初始化信号集中的每个信号值。  
> 3）需要保护的临界代码前进行 P 操作。  
> 对信号值的获得操作 ，称为 P 操作  
> 4）执行完成临界代码后进行 V 操作。  
> 释放信号称为== V 操作==  
> 5） 不需要时候删除信号集

**5.4：信号量相关API：**

**创建/访问：**  
原型：

int semget(key_t key, int nsems, int semflg);

参数：  
key：键值

> IPC\_PRIVATE//键值为0 表示创建一个只有创建者进程才可以访问的信号量  
> ftok()//可以被多个进程共享的信号量  
> nsems  
> 需要使用的信号量数目  
> semflg  
> IPC\_CREAT

返回值:  
失败： -1；成功：正数，表示信号集的 id

**设置初始值:**  
原型:

int semctl(int semid, int semnum, int cmd, ...);

参数:

> semid  
> semget返回的信号量标识符  
> semnum  
> 要进行的操作的集合中信号量的编号，一般取0  
> cmd  
> 删除:IPC\_RMID  
> 设置一个:SETVAL  
> 获取一个:GETVAL  
> 获取全部:GETALL  
> 设置全部:SETALL  
> 设置属性:IPC\_SET  
> 获取属性:IPC\_STAT

**消耗/还原 信号量semop:**  
原型:

int semop(int semid, struct sembuf *sops, unsigned nsops);

功能:  
修改信号集合中的信号量值，实现 PV 操作  
参数:

> semid：semget返回值  
> sops：对信号量的操作  
> 封装了一个结构体里面有  
> unsigned short sem\_num; /\* 集合中的信号量编号，实际就是数组下标，从 0 开始 */  
> short sem\_op; /* 要调整的信号值,把原来的信号值进行+/- sem\_op 操作，一般是-1 或 1 */  
> short sem\_flg; /* 操作标志， IPC\_NOWAIT 表示当不能获得信号量时不阻塞，返回错误；  
> SEM\_UNDO 表示内核自动跟踪进程是否异常终止，如果持有信号量的进程异常中止，内核会还原信号量，  
> 避免其他进程得不到信号永久等待这种情况。一般设置为0。 \*/  
> nsops：表示要操作的信号量数量

**案例演示：**

创建2个进程，进行pv操作：

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/887580908f41469ba571c4012cd4eeb7.png
[20201017155940307.png_pic_center]: /images/20221123/6338323f8aa441bb9248f81abcad2c79.png
[20201017163718994.png_pic_center]: /images/20221123/cdee0bfb534e498f89c14bfe0eda7946.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/5ae27480ebf143ce913a9dec9ea67af3.png