LinuxC 进程间通信 --- 共享内存

最新推荐文章于 2024-05-06 17:54:39 发布
最新推荐文章于 2024-05-06 17:54:39 发布
阅读量149 收藏 2
点赞数
分类专栏： Linux C 进程 + 进程间通信 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44977283/article/details/132117246
版权

        让同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新；

        共享内存的使用步骤

1、进程调用shmget函数创建新的或获取已有共享内存

2、进程调用shmat函数，将物理内存映射到自己的进程空间

3、shmdt函数，取消映射

4、调用shmctl函数释放开辟的那片物理内存空间

创建共享内存：

有亲缘关系的两个进程通信：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>

#define SHM_NAME "./shm_file"
#define SHM_SIZE 4096
int shmid;
void *addr;

void my_exit(int sig)
{
    if (sig == SIGINT)
    {
        shmdt(addr);
        shmctl(shmid, IPC_RMID, NULL); // ipcrm -M + (shmid)
        exit(1);
    }
    else if (sig == SIGUSR1)
    {
    }
}

int main(int argc, char const *argv[])
{
    signal(SIGINT, my_exit);

    key_t key;
    pid_t pid;

    key = ftok(SHM_NAME, 's');
    // int shmget(key_t key, size_t size, int shmflg);
    shmid = shmget(key, SHM_SIZE, 0655 | IPC_CREAT);
    if (shmid < 0)
    {
        perror("shm get error!");
        exit(1);
    }
    /**
     * semflg：与消息队列一样
     * 指定原始权限和IPC_CREAT，比如0664|IPC_CREAT。
     * 只有在创建一个新的共享内存时才会用到，否者不会用到
     */

    printf("key = %x\n", key);
    printf("shmid = %d\n", shmid);

    pid = fork();

    if (pid < 0)
    {
        perror("fork error:");
        exit(1);
    }

    if (pid == 0)
    {
        char buffer[1024];
        // void *shmat(int shmid, const void *shmaddr, int shmflg);
        addr = shmat(shmid, NULL, 0);
        if (addr == (void *)-1)
        {
            perror("shm error:\n");
            exit(1);
        }
        /**
         * 将shmid所指向的共享内存空间映射到进程空间（虚拟内存空间），并返回影射后的起始地址（虚拟地址）。
         * 有了这个地址后，就可以通过这个地址对共享内存进行读写操作
         * shmaddr：指定映射的起始地址有两种设置方式
         *      自己指定映射的起始地址（虚拟地址）。
         *      我们一般不会这么做，因为我们自己都搞不清哪些虚拟地址被用了，哪些没被用。
         *      NULL：表示由内核自己来选择映射的起始地址（虚拟地址）。
         * 这是最常见的方式，也是最合理的方式，因为只有内核自己才知道哪些虚拟地址可用，哪些不可用。
         * shmflg：指定映射条件。
         *          0:以可读可写的方式映射共享内存也就是说映射后，可以读、也可以写共享内存。
         *          SHM_RDONLY：以只读方式映射共享内存也就是说映射后，只能读共享内存，不能写。
         */

        while (1)
        {
            memset(buffer, 0, sizeof(buffer));

            scanf("%s", buffer);
            memcpy(addr, buffer, strlen(buffer));
            kill(getppid(), SIGUSR1);
        }
    }

    else if (pid > 0)
    {
        char buffer[1024];

        signal(SIGUSR1, my_exit);

        addr = shmat(shmid, NULL, 0); // 获得映射的地址
        if (addr == (void *)-1)
        {
            perror("shm error:\n");
            exit(1);
        }

        while (1)
        {
#if 0 // 非阻塞 -- 浪费CPU资源
            if (strlen((char *)addr) != 0)
            {
                memset(buffer, 0, sizeof(buffer));
                memcpy(buffer, addr, strlen((char *)addr));
                printf("recv data = %s\n", buffer);
                memset(addr, 0, SHM_SIZE);
            }
#endif
            // 阻塞
            pause(); // 没有数据的时候先挂起
            memset(buffer, 0, sizeof(buffer));
            memcpy(buffer, addr, strlen((char *)addr));
            printf("recv data = %s\n", buffer);
            memset(addr, 0, SHM_SIZE);
            sleep(1);
        }
    }

    return 0;
}

运行结果如下：

superlan@GodFather:~/C_Language/interprocess_communication$ ./a.out 
key = ffffffff
shmid = 33
xiaobai
recv data = xiaobai
super
recv data = super

---------------------------------------------------------------------------------------------------------------------------------

两个没有亲缘关系的进程通信：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>

#define SHM_NAME "./shm_file"
#define FIFO_NAME "./fifo_file"
#define SHM_SIZE 4096

int shmid;
void *addr;

pid_t recv_pid() // 接受管道文件
{
    int fd = open(FIFO_NAME, O_RDONLY);
    if (fd < 0)
    {
        perror("open fifo error:");
        exit(1);
    }
    pid_t pid;

    if (read(fd, &pid, sizeof(pid)) < 0) // 获得 pid 的值
    {
        perror("send pid error:");
        exit(1);
    }

    return pid;
}

void my_exit(int sig)
{
    if (sig == SIGINT)
    {
        shmdt(addr);
        // int shmdt(const void *shmaddr);
        /**
         * 功能：取消建立的映射。
         * 返回值：调用成功返回0，失败返回-1，且errno被设置。
         * 参数：shmaddr：映射的起始地址（虚拟地址）
         **/
        shmctl(shmid, IPC_RMID, NULL);
        // 调用shmctl函数释放开辟的那片物理内存空间
        remove(FIFO_NAME);
        exit(1);
    }
    else if (sig == SIGUSR1)
    {
    }
}

int main(int argc, char const *argv[])
{
    key_t key;
    char buffer[1024];

    key = ftok(SHM_NAME, 's');

    shmid = shmget(key, SHM_SIZE, 0655 | IPC_CREAT);

    if (shmid < 0)
    {
        perror("shm get error!");
        exit(1);
    }

    printf("key = %x\n", key);
    printf("shmid = %d\n", shmid);

    signal(SIGINT, my_exit);
    signal(SIGUSR1, my_exit);

    addr = shmat(shmid, NULL, 0);

    if (addr == (void *)-1)
    {
        perror("shn error:\n");
        exit(1);
    }

    pid_t pid = recv_pid();

    while (1)
    {
        memset(buffer, 0, sizeof(buffer));

        scanf("%s", buffer);
        memcpy(addr, buffer, strlen(buffer));
        kill(pid, SIGUSR1);
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>

#define SHM_NAME "./shm_file"
#define FIFO_NAME "./fifo_file"
#define SHM_SIZE 4096

int shmid;
void *addr;

void my_exit(int sig)
{
    if (sig == SIGINT)
    {
        shmdt(addr);
        shmctl(shmid, IPC_RMID, NULL);
        exit(1);
    }
    else if (sig == SIGUSR1) // 空处理
    {
    }
}

void send_pid()
{
    if (mkfifo(FIFO_NAME, 0655 | IPC_CREAT) < 0) // 创建管道文件
    {
        perror("mkfifo error:");
        exit(1);
    }

    int fd = open(FIFO_NAME, O_WRONLY); // 以只读的方式打开
    if (fd < 0)
    {
        perror("open fifo error:");
        exit(1);
    }
    pid_t pid = getpid();

    if (write(fd, &pid, sizeof(pid)) < 0) // 发送这个Pid
    {
        perror("send pid error:");
        exit(1);
    }
}

int main(int argc, char const *argv[])
{
    key_t key;
    pid_t pid;
    char buffer[1024];

    key = ftok(SHM_NAME, 's');

    shmid = shmget(key, SHM_SIZE, 0655 | IPC_CREAT);

    if (shmid < 0)
    {
        perror("shm get error!");
        exit(1);
    }

    printf("key = %x\n", key);
    printf("shmid = %d\n", shmid);

    send_pid();

    signal(SIGINT, my_exit);
    signal(SIGUSR1, my_exit);

    addr = shmat(shmid, NULL, 0);
    if (addr == (void *)-1)
    {
        perror("shn error:\n");
        exit(1);
    }

    while (1)
    {
        memset(buffer, 0, sizeof(buffer));
        /*void
        if (strlen((char *)addr) != 0)
        {
            memcpy(buffer, addr, strlen((char *)addr));
            printf("recv data = %s\n", buffer);
            memset(addr, 0, SHM_SIZE);
        }
        */

        pause();

        memcpy(buffer, addr, strlen((char *)addr));
        printf("recv data = %s\n", buffer);
        memset(addr, 0, SHM_SIZE);
    }
    return 0;
}

运行结果如下：

 共享内存的特点：

1、减少进入内核空间的次数

2、直接使用地址来读写缓存时，效率会更高，适用于大数据量的通信

Super小白&
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 共享内存
小灰灰的博客
07-07 2496
创建共享内存：在Linux系统中，可以使用shmget函数来创建一个共享内存标识符。该函数需要指定共享内存的大小、权限等参数，并返回一个唯一的标识符。连接共享内存：使用shmat函数将进程与共享内存进行连接，该函数需要传入共享内存标识符和一个用户指定的地址，如果地址为0，则由系统选择一个可用的地址。使用共享内存：连接成功后，进程可以像使用普通内存一样使用共享内存，通过读写共享内存实现进程间的数据交换。分离共享内存：使用shmdt函数将进程与共享内存分离，分离后进程不能再访问共享内存。
Linux使用共享内存
lyq_csdn的博客
10-24 1082
转自：http://blog.csdn.net/ljianhui/article/details/10253345 https://www.cnblogs.com/52php/p/5851570.html 下面将讲解进程间通信的另一种方式，使用共享内存。   一、什么是共享内存 顾名思义，共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据...
linuxC-共享内存
最新发布
qq_52660422的博客
05-06 1039
共享内存是一种进程间通信的机制，它允许两个或多个进程共享同一块内存区域。在共享内存中，进程可以读取和写入内存中的数据，从而实现进程间的数据交换。
【Linux】共享内存（超详细！）
zzxz8的博客
08-14 3750
通过在物理内存申请一段共享内存空间，这个空间可以被任何进程看见。然后将内存空间映射到想要以此进行通信的进程的进程地址空间中的共享区（堆栈之间），用户就可以直接使用这个虚拟起始地址进行数据传输和接收了。
linux下C语言实现进程通信与共享内存
weixin_43643793的博客
07-26 724
先执行sem_P.c（./sem_P 1 -10），输入一个-10传给灯ss1的value，让该进程处于阻塞状态，然后执行sem_V.c（./sem_V.c 1 2），每次执行灯ss1就会加2，执行5次后ss1的value会加到10，此时原来ss1的value = -10会被抵消为0，sem_P.c解除阻塞，打印“NO WAIT”，这就是进程的同步。进程通信的操作并不难，难就难在函数多，参数多，参数还结合了结构体联合体，就很恶心，这也是我大部分代码都是介绍函数的原因，重点在对各种API函数的介绍上。
《Linux C编程实战》笔记：共享内存
ouliten的博客
03-02 1000
由于本人要考研了，播客可能不会再长更。这本《Linux C编程实战》其实也差不多完结了，还剩网络编程章节没有讲，我肯定是没时间讲了，可能考研失败了会回来继续。《Primer C++》的课后题还有第八章的存货，后续章节只能随缘更新。Qt部分真烂尾了，写Qt项目的注释实在太累了。最有可能更新的部分是力扣题讲解，因为写来准备复试上机。最后祝大家，也祝我一切顺利。
Linux进程间通信之共享内存
07-26
本文主要介绍Linux进程间通信中共享内存的知识，感兴趣的朋友可以看看。
linux下C语言编程4-使用共享内存实现进程间通信.doc
06-21
Linux 下 C 语言编程使用共享内存实现进程间通信 共享内存是 Linux 操作系统中的一种进程间通信机制，它允许不同的进程访问同一个内存区域，从而实现进程间的数据交换。在 C 语言中，使用共享内存可以通过 shmget、...
linux c 进程间通信(共享内存+消息队列)
07-28
**共享内存**是Linux进程间通信的一种高效方式，它允许不同的进程直接访问同一块内存空间。在C语言中，可以使用`<sys/shm.h>`头文件中的函数来操作共享内存。创建共享内存的关键步骤包括： 1. **创建共享内存**：...
Linux进程间通信-信号通信实例.pdf
07-11
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程间进行数据交换的重要手段。本文将深入探讨一种常见的IPC方式——信号（Signal）通信，通过几个实例来阐述其基本概念和使用方法。 ...
linux c 进程间通信 共享内存的操作 源代码
03-01
linux c 进程间通信 共享内存的操作 源代码
【Linux】进程间通信之共享内存
Sxy_wspsby的博客
05-06 1426
共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据.使用ipcrm -m 命令删除指定共享内存后，是不会直接释放共享内存的，因为共享内存的生命周期是随操作系统的，只有共享内存当前的映射链接数为0才会被删除释放。使用ipcrm -a 可以删除所有进程间通信资源（a代表all也就是全部的意思）ipcrm -m删除共享内存，-q删除消息队列，-s删除信号量。
【Linux】进程通信 — 共享内存
上上谦. 的博客
07-29 1413
上一章我们由进程通信，引入并讲述了管道，匿名管道和命名管道和匿名管道。本章我们将继续讲解进程通信的另一种方式，通过共享内存的方式来进行进程间的通信。还要学习几个系统调用接口，并用代码实现两个进程通过共享内存来进行通信。目标已经确定，接下来就要搬好小板凳，准备开讲了…🙆🙆🙆🙆。
Linux共享内存
C语言实战技术
03-05 794
文章目录一、共享内存的概念二、相关函数1、shmget函数2、shmat函数3、shmdt函数4、shmctl函数三、示例程序四、其它的操作命令在这里插入图片描述 五、版权声明 一、共享内存的概念 共享内存（Shared Memory）就是允许多个进程访问同一个内存空间，是在多个进程之间共享和传递数据最高效的方式。操作系统将不同进程之间共享内存安排为同一段物理内存，进程可以将共享内存连接到它们自己...
进程间通信------共享内存
zhangye3017的博客
05-04 866
更多linux知识点：linux目录索引 1. 什么是共享内存    共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存一样。而如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。 ...
Linux C/C++共享内存
Abieai的博客
04-20 3146
文章目录一、共享内存二、案例实现总结 一、共享内存 共享存储允许两个或多个进程共享一给定的存储区。因为数据不需要在客户机和服务器之间复制，所以这是最快的一种 I P C。使用共享存储的唯一窍门是多个进程之间对一给定存储区的同步存取。若服务器将数据放入共享存储区，则在服务器做完这一操作之前，客户机不应当去取这些数据。通常，信号量被用来实现对共享存储存取的同步。 常用函数 #include<sys/ipc.h> #include<sys/shm.j> int shmget(key_t
C语言笔记-23-Linux基础-共享内存
宝全哥哥的博客
12-14 574
自学笔记，没有历史知识铺垫（省略百度部分）C语言笔记-23-Linux基础-共享内存本章主要为C语言笔记-23-Linux基础-共享内存。
linux c 进程通信之共享内存入门
我的博客
09-25 111
linux c 进程通信之共享内存入门
Linux进程通信之共享内存
m0_60010936的博客
12-01 1273
Linux 共享内存
linux c++ 进程间通信 共享内存
12-28
在Linux C编程中，可以通过使用共享内存机制来实现进程间通信。首先，需要通过系统调用shmget来创建一个共享内存区域，并返回一个唯一的标识符。然后使用shmat将共享内存附加到进程的地址空间中，使得进程可以访问...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值