【共享内存】

已于 2023-04-05 22:16:50 修改
阅读量954 收藏 2
点赞数 2
分类专栏： c++ Linux 后端开发 文章标签： c++ linux
于 2023-04-05 21:47:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43899283/article/details/129976254
版权
c++ 同时被 3 个专栏收录
35 篇文章 2 订阅
订阅专栏
Linux
9 篇文章 0 订阅
订阅专栏
后端开发
7 篇文章 0 订阅
订阅专栏

共享内存

1. 概述

  共享内存是一种进程间通信（IPC）的机制，允许不同的进程共享同一块内存区域。这样，多个进程可以同时访问和修改共享内存中的数据，从而达到数据共享的目的。
  共享内存通常由一个进程创建，并通过特定的系统调用将其附加到其他进程的地址空间中。进程可以通过读写共享内存中的数据来进行通信和同步。由于共享内存的访问速度非常快，因此它是一种高效的进程间通信机制。
  但是，由于多个进程可以同时访问和修改共享内存中的数据，因此需要特殊的同步机制来避免数据竞争和其他并发问题。常见的同步机制包括信号量、互斥量和条件变量等。

2. 案例分析（同步执行）

  话不多说，直接上代码。

写进程（shm_write.c）

/* Filename: shm_write.c */
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

#define BUF_SIZE 1024
#define SHM_KEY 0x1234

struct shmseg {
   int cnt;             //计数器
   int complete;        //标志位
   char buf[BUF_SIZE];  //长度为BUF_SIZE 的缓冲区
};
int fill_buffer(char * bufptr, int size);

int main(int argc, char *argv[]) {
   int shmid, numtimes;
   struct shmseg *shmp; //创建共享内存区域
   char *bufptr;
   int spaceavailable;
   //shmget函数用于创建共享内存段
   shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT); //SHM_KEY 是一个用户定义的常量，它是一个键值，用于标识共享内存段。
   if (shmid == -1) {
      perror("Shared memory");
      return 1;
   }

   // Attach to the segment to get a pointer to it.
   shmp = shmat(shmid, NULL, 0);
   if (shmp == (void *) -1) {
      perror("Shared memory attach");
      return 1;
   }

   /* Transfer blocks of data from buffer to shared memory */
   bufptr = shmp->buf;
   spaceavailable = BUF_SIZE;
   for (numtimes = 0; numtimes < 5; numtimes++) {
      shmp->cnt = fill_buffer(bufptr, spaceavailable);
      shmp->complete = 0;
      printf("Writing Process: Shared Memory Write: Wrote %d bytes\n", shmp->cnt);
      bufptr = shmp->buf;
      spaceavailable = BUF_SIZE;
      sleep(3);
   }
   printf("Writing Process: Wrote %d times\n", numtimes);
   shmp->complete = 1;

   if (shmdt(shmp) == -1) {
      perror("shmdt");
      return 1;
   }

   if (shmctl(shmid, IPC_RMID, 0) == -1) {
      perror("shmctl");
      return 1;
   }
   printf("Writing Process: Complete\n");
   return 0;
}

int fill_buffer(char * bufptr, int size) {
   static char ch = 'A';
   int filled_count;

   //printf("size is %d\n", size);
   memset(bufptr, ch, size - 1);
   bufptr[size-1] = '\0';
   if (ch > 122)
   ch = 65;
   if ( (ch >= 65) && (ch <= 122) ) {
      if ( (ch >= 91) && (ch <= 96) ) {
         ch = 65;
      }
   }
   filled_count = strlen(bufptr);

   //printf("buffer count is: %d\n", filled_count);
   //printf("buffer filled is:%s\n", bufptr);
   ch++;
   return filled_count;
}
//更多请阅读：https://www.yiibai.com/ipc/shared_memory.html

  这是一个使用共享内存实现进程间通信的程序。它创建了一个共享内存区域，然后向其中写入数据。下面是代码的大致流程：

  1. 定义了一个结构体 shmseg，其中包含了一个计数器、一个标志位以及一个长度为 BUF_SIZE 的缓冲区。
  2. 主函数中调用了 shmget 函数来创建共享内存区域，如果创建失败则输出错误信息并退出程序。
  3. 调用 shmat 函数将进程附加到共享内存区域，获取到了一个指向共享内存区域的指针，如果失败则输出错误信息并退出程序。
  4. 主函数中通过循环向共享内存区域写入数据。具体来说，它调用了一个名为 fill_buffer 的函数，该函数填充缓冲区，然后将缓冲区中的数据写入共享内存区域。循环执行 5 次，每次等待 3 秒钟。
  5. 写入完成后，主函数将 complete 标志位置为 1，然后通过调用 shmdt 函数将进程从共享内存区域分离，最后调用 shmctl 函数删除共享内存区域。
  6. 程序运行完毕，主函数输出 "Writing Process: Complete"。

总之，这是一个向共享内存区域写入数据的程序。它创建了一个共享内存区域，然后将数据写入其中。该程序可以与另一个程序共同使用，以实现进程间通信。

shmget结构体和shmget函数的区别

  1. shmget 函数用于创建或访问一个共享内存段。它的函数原型为：
int shmget(key_t key, size_t size, int shmflg);

它接受三个参数：
  （1）key：用于标识共享内存段的键值，可以通过 ftok 函数生成。
  （2）size：指定共享内存段的大小（以字节为单位）。
  （3）shmflg：指定访问权限和其他标志。
  shmget 函数返回共享内存段的标识符（也称为共享内存段的 ID）。如果共享内存段已经存在，则返回它的标识符；如果共享内存段不存在，则根据指定的 size 创建一个新的共享内存段，并返回它的标识符。
2. struct shmseg 结构体定义了共享内存段中存储的数据的格式。它包含三个成员：
  （1）cnt：表示缓冲区中存储的数据的长度。
  （2）complete：一个标志，用于表示数据是否已经全部写入共享内存段。
  （3）buf：一个字符数组，用于存储实际的数据。
  在程序中，使用 shmget 函数创建了一个共享内存段，然后使用 struct shmseg 结构体来表示该共享内存段中存储的数据。程序使用共享内存段来实现两个进程之间的通信，其中一个进程用于写入数据，另一个进程用于读取数据。
  因此，shmget 函数和 struct shmseg 结构体的作用不同，但它们都是实现共享内存通信的关键组成部分。

shmat函数的作用

  shmat 函数用于将进程与一个共享内存段关联起来，从而使得进程可以访问共享内存段中的数据。它的函数原型为：

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

它接受三个参数：
  （1）shmid：共享内存段的标识符，它是由 shmget 函数返回的。
  （2）shmaddr：指定共享内存段将要被映射到进程的地址。通常传入 NULL，表示让系统自动选择一个合适的地址。
  （3）shmflg：指定映射方式和其他标志。
  shmat 函数返回一个指向共享内存段第一个字节的指针，如果出现错误，则返回 (void *)-1。
  在这个程序中，shmat 函数用于将当前进程与共享内存段关联起来，从而使得进程可以访问共享内存段中的数据。具体来说，程序在调用 shmget 函数创建共享内存段之后，通过 shmat 函数将 struct shmseg 结构体映射到共享内存段上，这样就可以在进程中使用该结构体来访问共享内存段中的数据了。

fill_buffer函数

  fill_buffer 函数的作用是将指定的缓冲区填充为重复的字母序列，直到缓冲区填满为止。
  具体来说，fill_buffer 函数的第一个参数 bufptr 是一个指向缓冲区的指针，第二个参数 size 是缓冲区的大小（以字节为单位）。函数首先将一个静态的字符变量 ch 赋值为 'A'，然后使用 memset 函数将缓冲区填充为 size-1 个 ch 字符，最后将缓冲区的最后一个字符设置为 '\0'，以确保缓冲区可以当作一个 C 语言风格的字符串使用。
  如果 ch 的值超过了字母表的最后一个字符 'z'，则将 ch 的值重置为字母表的第一个字符 'A'。此外，fill_buffer 函数还会返回实际填充缓冲区的字符个数（即不包括最后一个 '\0' 字符）。
  在该程序中，fill_buffer 函数用于向共享内存段中写入数据，即将缓冲区填充为字母序列，然后将数据写入到共享内存段中。在写入数据之前，程序将缓冲区的地址赋给指向共享内存段的指针 shmp->buf，这样程序就可以通过 shmp->buf 指针来访问共享内存段中的缓冲区了。具体来说，程序在循环中反复调用 fill_buffer 函数，将缓冲区填充为不同的字母序列，然后将填充后的数据写入到共享内存段中。

shmdt函数

  shmdt()函数是用于将共享内存从进程的地址空间中分离的函数。调用该函数后，进程将不能再访问共享内存中的数据。该函数的函数原型如下：

#include <sys/shm.h>
int shmdt(const void *shmaddr);

  其中，参数shmaddr是指向共享内存段附加到进程地址空间的指针。
  如果分离成功，shmdt()函数返回0，否则返回-1，并设置errno变量来指示错误原因。
  在使用共享内存完成数据传输之后，需要使用shmdt()函数将共享内存从进程的地址空间中分离。这是一个很重要的步骤，因为共享内存是由多个进程共享的资源，而不是属于某个进程的私有资源，如果不使用shmdt()函数将共享内存分离，可能会导致其他进程无法访问该共享内存，造成资源泄漏等问题。

读进程（shm_read.c）

/* Filename: shm_read.c */
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>

#define BUF_SIZE 1024
#define SHM_KEY 0x1234

struct shmseg {
   int cnt;             //计数器
   int complete;        //标志位
   char buf[BUF_SIZE];  //长度为BUF_SIZE 的缓冲区
};

int main(int argc, char *argv[]) {
   int shmid;
   struct shmseg *shmp;
   shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);
   if (shmid == -1) {
      perror("Shared memory");
      return 1;
   }

   // Attach to the segment to get a pointer to it.
   shmp = shmat(shmid, NULL, 0);
   if (shmp == (void *) -1) {
      perror("Shared memory attach");
      return 1;
   }

   /* Transfer blocks of data from shared memory to stdout*/
   while (shmp->complete != 1) {
      printf("segment contains : \n\"%s\"\n", shmp->buf);
      if (shmp->cnt == -1) {
         perror("read");
         return 1;
      }
      printf("Reading Process: Shared Memory: Read %d bytes\n", shmp->cnt);
      sleep(3);
   }
   printf("Reading Process: Reading Done, Detaching Shared Memory\n");
   if (shmdt(shmp) == -1) {
      perror("shmdt");
      return 1;
   }
   printf("Reading Process: Complete\n");
   return 0;
}
//更多请阅读：https://www.yiibai.com/ipc/shared_memory.html

  这段代码实现了一个使用共享内存的读进程。这段代码的作用是从共享内存中读取数据并输出到标准输出流，主要用于进程间通信。以下是代码的详细解读：

  1. 包含必要的头文件：stdio.h、sys/ipc.h、sys/shm.h、sys/types.h、string.h、`errno.h、stdlib.h。
  2. 定义常量：BUF_SIZE表示共享内存中的缓冲区大小为1024，SHM_KEY表示共享内存的键值为0x1234。
  3. 定义了一个结构体shmseg，包括三个成员变量：cnt表示缓冲区中实际数据的大小；complete表示是否读取完毕；buf表示共享内存中的缓冲区。
  4. main()函数首先创建共享内存，如果创建失败则输出错误信息并返回1。
  5. 通过shmat()函数将共享内存附加到进程的地址空间，返回一个指向共享内存的指针，如果附加失败则输出错误信息并返回1。
  6. 在一个循环中，读进程从共享内存中读取数据并输出到标准输出流，如果读取出错则输出错误信息并返回1。
  7. 如果complete成员变量被设置为1，表明读取完毕，此时读进程将共享内存从地址空间中分离，如果分离失败则输出错误信息并返回1。
  8. 最后，读进程输出“Reading Process: Complete”，并返回0表示正常退出。

运行结果

在这里插入图片描述

3. 案例分析（进程同步）

  发现问题： 在以上代码中，使用了一个简单的标志位complete来指示进程是否已经完成对共享内存的读写操作。标志位的值为0表示正在写入，值为1表示写入已完成，读取进程可以根据该标志位的值来判断何时停止读取。如果使用信号量来控制进程对共享内存的访问，则可以更加精细地控制读写进程之间的同步，从而避免竞态条件和数据不一致等问题。

写进程（shm_writes_sem.c）

/* Filename: shm_write.c */
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <semaphore.h> //添加了信号量的头文件

#define BUF_SIZE 1024
#define SHM_KEY 0x1234

struct shmseg
{
    int cnt;            // 计数器
    int complete;       // 标志位
    char buf[BUF_SIZE]; // 长度为BUF_SIZE 的缓冲区
};
int fill_buffer(char *bufptr, int size);

int main(int argc, char *argv[])
{
    int shmid, numtimes;
    struct shmseg *shmp; // 创建共享内存区域
    char *bufptr;
    int spaceavailable;
    sem_t *sem_read, *sem_write;
    sem_read = sem_open("/sem_read", O_CREAT, 0644, 0);
    sem_write = sem_open("/sem_write", O_CREAT, 0644, 1);

    // shmget函数用于创建共享内存段
    shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644 | IPC_CREAT); // SHM_KEY 是一个用户定义的常量，它是一个键值，用于标识共享内存段。
    if (shmid == -1)
    {
        perror("Shared memory");
        return 1;
    }

    // Attach to the segment to get a pointer to it.
    shmp = shmat(shmid, NULL, 0);
    if (shmp == (void *)-1)
    {
        perror("Shared memory attach");
        return 1;
    }

    /* Transfer blocks of data from buffer to shared memory */
    bufptr = shmp->buf;
    spaceavailable = BUF_SIZE;
    for (numtimes = 0; numtimes < 5; numtimes++)
    {
        // 等待信号量，保证同步
        sem_wait(sem_write);
        shmp->cnt = fill_buffer(bufptr, spaceavailable);
        shmp->complete = 0;
        printf("Writing Process: Shared Memory Write: Wrote %d bytes\n", shmp->cnt);
        bufptr = shmp->buf;
        spaceavailable = BUF_SIZE;
        sleep(3);
        // 释放信号量
        sem_post(sem_read); // 发送读取信号量
    }
    printf("Writing Process: Wrote %d times\n", numtimes);
    shmp->complete = 1;

    if (shmdt(shmp) == -1)
    {
        perror("shmdt");
        return 1;
    }

    if (shmctl(shmid, IPC_RMID, 0) == -1)
    {
        perror("shmctl");
        return 1;
    }
    // 关闭信号量
    sem_close(sem_read);
    sem_close(sem_write);
    sem_unlink("/sem_read");
    sem_unlink("/sem_write");
    printf("Writing Process: Complete\n");
    return 0;
}

int fill_buffer(char *bufptr, int size)
{
    static char ch = 'A';
    int filled_count;

    // printf("size is %d\n", size);
    memset(bufptr, ch, size - 1);
    bufptr[size - 1] = '\0';
    if (ch > 122)
        ch = 65;
    if ((ch >= 65) && (ch <= 122))
    {
        if ((ch >= 91) && (ch <= 96))
        {
            ch = 65;
        }
    }
    filled_count = strlen(bufptr);

    // printf("buffer count is: %d\n", filled_count);
    // printf("buffer filled is:%s\n", bufptr);
    ch++;
    return filled_count;
}
// 更多请阅读：https://www.yiibai.com/ipc/shared_memory.html

读进程（shm_read_sem.c）

/* Filename: shm_read.c */
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <semaphore.h> //添加了信号量的头文件

#define BUF_SIZE 1024
#define SHM_KEY 0x1234

struct shmseg
{
    int cnt;            // 计数器
    int complete;       // 标志位
    char buf[BUF_SIZE]; // 长度为BUF_SIZE 的缓冲区
};

int main(int argc, char *argv[])
{
    int shmid;
    struct shmseg *shmp; // 创建共享内存区域
    sem_t *sem_read, *sem_write;
    sem_read = sem_open("/sem_read", O_CREAT, 0644, 0);
    sem_write = sem_open("/sem_write", O_CREAT, 0644, 1);

    shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644 | IPC_CREAT);
    if (shmid == -1)
    {
        perror("Shared memory");
        return 1;
    }

    // Attach to the segment to get a pointer to it.
    shmp = shmat(shmid, NULL, 0);
    if (shmp == (void *)-1)
    {
        perror("Shared memory attach");
        return 1;
    }

    /* Transfer blocks of data from shared memory to stdout*/
    while (shmp->complete != 1)
    {
        sem_wait(sem_read); // 等待读取信号量
        printf("segment contains : \n\"%s\"\n", shmp->buf);
        if (shmp->cnt == -1)
        {
            perror("read");
            return 1;
        }
        printf("Reading Process: Shared Memory: Read %d bytes\n", shmp->cnt);
        sem_post(sem_write); // 发送写入信号量
        sleep(3);
    }
    printf("Reading Process: Reading Done, Detaching Shared Memory\n");

    if (shmdt(shmp) == -1)
    {
        perror("shmdt");
        return 1;
    }

    if (shmctl(shmid, IPC_RMID, 0) == -1)
    {
        perror("shmctl");
        return 1;
    }

    sem_close(sem_read);
    sem_close(sem_write);
    sem_unlink("/sem_read");
    sem_unlink("/sem_write");
    printf("Reading Process: Complete\n");
    return 0;
}
// 更多请阅读：https://www.yiibai.com/ipc/shared_memory.html

  在这个例子中，可以使用两个二进制信号量（semaphore）来同步和保护共享内存的读和写：

  1. 创建两个二进制信号量：
#include <semaphore.h>
#include <fcntl.h>

sem_t *sem_read, *sem_write;
sem_read = sem_open("/sem_read", O_CREAT, 0644, 0);
sem_write = sem_open("/sem_write", O_CREAT, 0644, 1);

  以上创建了两个二进制信号量，一个用于读取进程sem_read ，一个用于写入进程sem_write 。 初始值分别为0和1，以确保写入进程可以立即开始写入。

  1. 在写入进程中，在开始写入之前获取写信号量，完成写入后释放读信号量。
sem_wait(sem_write); // 等待写入信号量
shmp->cnt = fill_buffer(bufptr, spaceavailable);
shmp->complete = 0;
printf("Writing Process: Shared Memory Write: Wrote %d bytes\n", shmp->cnt);
bufptr = shmp->buf;
spaceavailable = BUF_SIZE;
sem_post(sem_read); // 发送读取信号量
  1. 在读取进程中，在读取之前获取读取信号量，读取完成后释放写信号量。
while (shmp->complete != 1) {
   sem_wait(sem_read); // 等待读取信号量
   printf("segment contains : \n\"%s\"\n", shmp->buf);
   if (shmp->cnt == -1) {
      perror("read");
      return 1;
   }
   printf("Reading Process: Shared Memory: Read %d bytes\n", shmp->cnt);
   sem_post(sem_write); // 发送写入信号量
   sleep(3);
}

  这确保了在读取完成之前不会有其他进程写入新的数据。

  1. 在完成操作之后删除信号量。
sem_close(sem_read);
sem_close(sem_write);
sem_unlink("/sem_read");
sem_unlink("/sem_write");

致谢：本章学习参考连接（https://www.yiibai.com/ipc/shared_memory.html）

J.Kuchiki
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
PHP共享内存用法实例分析
12-18
本文实例讲述了PHP共享内存用法。分享给大家供大家参考，具体如下： 共享内存主要用于进程间通信 php中的共享内存有两套扩展可以实现 1、shmop  编译时需要开启 –enable-shmop 参数 实例： $shm_key = ftok(__FILE__, 't'); /** 开辟一块共享内存 int $key , string $flags , int $mode , int $size $flags: a:访问只读内存段 c:创建一个新内存段，或者如果该内存段已存在，尝试打开它进行读写 w:可读写的内存段 n:创建一个新内存段，如果该内存段已存在，则会失败
一文搞懂共享内存
m0_73731708的博客
09-21 627
共享内存是在多个进程之间共享和访问相同的内存区域的一种机制。以下是共享内存的几个特点：快速：共享内存是一种高效的进程间通信方式，因为它直接在进程之间共享内存区域，不需要复制数据，避免了数据的拷贝开销，提高了访问数据的速度。高容量：共享内存可以承载大量的数据，适用于需要共享大量数据的场景。实时性：由于共享内存是直接在进程之间共享数据，进程可以实时地读取和修改共享内存中的数据，实现了实时更新和同步。灵活性：共享内存可以作为一个共享的缓冲区，使进程可以通过读写共享内存来进行进程间的协作。
进程间通信--共享内存篇
qq_63412763的博客
12-15 1671
共享内存字面理解就是进程间共同享有的存储空间，不同于管道通信，共享内存就像是进程自己的空间一样，不像管道文件还得使用文件描述符去访问文件，通过文件交流信息。共享内存则是实时信息交流，几乎不存在信息的中间转换。那么共享内存在哪里呢？就真的是在每个进程中都保留一份么？也不是，开辟的共享内存在整个内存空间中独一份，但是可以通过页表映射到不同的进程中去，让各个进程都能够看到这份资源，实现通信
在Linux测试共享共享内存消息
06-24
在Linux测试共享共享内存消息
mfc 共享内存
03-18
mfc 共享内存，支持WIN32,支持x64，支持vs2013,2017各种版本。
【共享内存】共享内存（Shared Memory）与进程通信
crr411422的博客
06-29 5356
共享内存作为一种高效的进程间通信机制，以其独特的优势在多进程环境中发挥着重要的角色。它允许多个进程直接访问同一块内存区域，从而实现了数据的快速共享和交换，显著提高了系统性能。然而，这也带来了数据同步和并发控制的挑战。我们需要结合锁、信号量等同步技术来解决这些问题。 总的来说，共享内存是一种强大而灵活的工具，但需要谨慎、有效地使用，以确保程序的正确性和稳定性。
共享内存(进程间的通信方式)
m0_68210771的博客
07-31 5684
共享内存，函数接口定义及代码演示
Linux——详解共享内存shared memory
热门推荐
weixin_61857742的博客
12-12 1万+
共享内存本质上就是内存中的一块区域，用于进程间通信使用。该内存空间由操作系统分配与管理。与文件系统类似的是，操作系统在管理共享内存时，不仅仅有内存数据块，同时还会创建相应结构体来记录该共享内存属性，以便于管理。因此，共享内存不只有一份，可以根据需求申请多个。进程之间进行通信的时候，会获取 到共享内存的地址，写端进程写入数据，读端进程通过直接访问内存完成数据读取。
【Linux操作系统】共享内存
weixin_63449996的博客
06-23 2247
Linux操作系统——共享内存。
五、共享内存
weixin_57886538的博客
01-20 1949
总结:共享内存是进程间通信方式中效率最高的，原因在于进程是直接在物理内存上进行操作，将物理地址映射到用户进程这，所以只要对其地址进行操作，就是直接对物理地址操作.4G的虚拟内存空间分为3G的用户空间和1G内核空间，由于进程间的都有自己独立的虚拟地址空间，所以需要通过共享内存进行通信。一个进程向共享的内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。测试：//通过shmget函数创建或者打开一个共享内存，返回一个共享内存的标识符。2.1、共享内存是进程间共享数据的一种最快的方法。
C#共享内存传递结构体数据
01-08
C#共享内存传递结构体数据
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存...
＜Linux系统复习＞共享内存
m0_62171658的博客
11-04 658
1、一段用来进程通信的内核缓冲区2、图解：3、系统可以创建多个共享内存，如何确保两个进程看到同一个共享内存？通过相同的key可以看到同一个共享内存，这个key是用来创建或获取共享内存的，用户可以传相同的key给两个进程，进程一用来创建一个全新的共享内存，进程二则用来获取进程一创建的共享内存，这样进程一和进程二就能看到相同的进程。4、两个进程要使用共享内存需要先做好以下几件事①创建/获取共享内存②关联共享内存：即地址空间和物理内存建立映射关系③去关联：去映射关系。
基于多进程并发-进程通讯之共享内存(shared memmory)
qq_43148810的博客
06-24 2578
现代操作系统，对于内存管理，采⽤的是虚拟内存技术，也就是每个进程都有⾃⼰独⽴的虚拟内存空间，不同进程的虚拟内存映射到不同的物理内存中。所以，即使进程A中和进程 B中的虚拟地址是⼀样的，其实访问的是不同的物理内存地址，对于数据的增删查改互不影响。就是拿出⼀块虚拟地址空间来，映射到相同的物理内存中。这样这个进程写⼊的东⻄，另外⼀个进程⻢上就能看到了，都不需要拷⻉来拷⻉去，传来传去，⼤⼤提⾼了进程间通信的速度。（1）共享内存是双向通信（全双工）。（2）共享内存是IPC通信方式中速度最快的。
共享内存（内存映射的使用、注意事项、进程间通信、systemV共享内存）
qq_36091214的博客
05-16 557
使一个磁盘文件与内存中的一个缓冲区相映射，进程可以像访问普通内存一样对文件进行访问，不必再调用read,write。mmap()的优点：实现了用户空间和内核空间的高效交互方式addr：指定要映射的内存地址，一般设置为 NULL 让操作系统自动选择合适的内存地址。length：必须>0。映射地址空间的字节数，它从被映射文件开头 offset 个字节开始算起。prot：指定共享内存的访问权限。
【Linux详解】——共享内存
HinsCoder的博客
09-05 1250
📖 前言：本期介绍共享内存。
系统5之共享内存
apple_71040140的博客
08-26 197
共享内存是一种最为高效的进程间通信方式，进 程可以直接读写内存，而不需要任何数据的拷贝。为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等。
十二、进程间通信——共享内存
weixin_54447296的博客
05-09 1888
共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。共享内存是一种用于实现进程间通信（IPC）的方法，不同进程通过访问同一块内存区域实现数据共享和交互。每个进程可以将自身的虚拟地址映射到物理内存中的特定区域，当不同进程将相同的物理内存区域与各自的虚拟地址空间关联时，这些进程就能实现通过共享内存来完成IPC。若某进程更改了共享内存区的内容，其它进程都会觉察到该区域的更改。
【C】 初识C语言
最新发布
努力学习C/C++
04-21 762
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
namespace 共享内存
09-07
namespace 共享内存 是一个用于实现共享内存的命名空间。在 C++ 中，共享内存是一种特殊的内存区域，可以被多个进程同时访问。通过共享内存，进程可以在不使用管道或消息队列的情况下进行进程间通信，从而提高数据传输的效率。 在 C++ 中，可以使用共享内存来实现进程间通信的一种方式是使用操作系统提供的共享内存机制。在 Linux 系统中，可以使用 System V 共享内存和 POSIX 共享内存两种机制来实现共享内存的操作。 在使用共享内存时，可以通过命名空间 namespace 共享内存 来提供一组相关的函数或类，方便开发者进行共享内存的操作。该命名空间中可能包含有创建共享内存、打开已存在的共享内存、读写共享内存等相关函数或类。 需要注意的是，具体实现方式可能会因操作系统和编译器的不同而有所差异。因此，在使用共享内存时，需要根据具体的平台和编译环境进行适配和调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值