共享内存在进程间应用

fpcc

已于 2023-07-20 11:07:16 修改

阅读量227

点赞数

分类专栏： C++ Linux 文章标签： c++

于 2023-07-20 10:59:15 首次发布

本文链接：https://blog.csdn.net/fpcc/article/details/131825462

版权

C++ 同时被 2 个专栏收录

229 篇文章 32 订阅

订阅专栏

Linux

26 篇文章 3 订阅

订阅专栏

一、共享内存

共享内存是指在内存空间中开辟出一段空间供多个进程使用，它是一种跨进程通信的重要手段。共享内存在多进程开发中应用非常多，特别是在跨进程间大数据量通信时，几乎是必备的选择。工程实践中，安卓的framework中就用到了它，当然其它很多知名的软件都有应用，有兴趣的可以自己查找看看。
Linux和Windows中共享内存的处理原理基本是相同的，但方式却有不同。本文只分析Linux下的共享内存，对Windows上的共享内存感兴趣的可以自己查找相关资料。
在Linux下，处理共享内存有两种方式：即传统的system V和Posix库两种形式。

二、共享内存在进程中使用中的同步锁

在进程通信中，最常遇到的就是两个问题，一个数据的读写操作，另外一个就是读写的同步问题。前者是基础的功能，这里重点分析一下同步问题。在实际的工程开发，在进程的锁选择中下意识的就选择了std::mutex。这和早年学习VC中的有名Mutex的影响非常大，在后期随着技术的演进，同时，多进程编程的实际工程少之又少，这也导致了很多问题。基本上的框架如下：

struct SmData final {
  bool flag = false;
  std::mutex mt;
  std::array<int, 100> buffer = {0};
};

struct MemData final {
  // WorkID id;
  SmData buf[2] = {0};
};

整体的测试流程是好的，但在测试时发现锁无效，两个进程中发送进程从共享内存中拿到mt锁住后，另外的接收进程也能从共享内存拿到锁。测试是好多次都是如此，查询网上得到的结果是std::mutex不可以用在进程间。查看一下其实现的源码：

  /// The standard mutex type.
  class mutex : private __mutex_base
  {
  public:
    typedef __native_type* 			native_handle_type;

#ifdef __GTHREAD_MUTEX_INIT
    constexpr
#endif
    mutex() noexcept = default;
    ~mutex() = default;

    mutex(const mutex&) = delete;
    mutex& operator=(const mutex&) = delete;
......
    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }
  };

也没有发现特别的定义。于是便换用了pthread_mutex_t,并将属性设置为PTHREAD_PROCESS_SHARED（注意，只在一个进程中设置即可，此处是在写入进程中设置，另外一个读进程只管操作即可），测试成功。然后重新封装了pthread_mutex_t的相关RAII类。
可仍然没有放弃对std::mutex的测试，采用了更准确的测试方式，发现标准库的std::mutex也可以，真的让人没办法，应该是前面的测试方法有问题，产生了误解。改了就改了吧，不改回去了。

POSIX的共享内存示例可以参看下面的网址：
https://www.bo-yang.net/2016/07/27/shared-memory-ring-buffer#shm_ring_buffer
很详细，说明也非常到位，就不再赘述。这里只说明，这种方式和创建一个内存映射类似，会在应用程序的指定位置生成一个文件，而且这个文件会随着开辟空间的增大而增大，这也是一个需要重视的问题。不过，也没有太大影响，毕竟硬盘的大小相对于内存来说不是一个量级的存在。

三、两个例程：

下面是两个反复测试的例程(含STL和Posix两种Mutex)，稍微有点乱：
下面是写共享内存的：

//send
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <mutex>
namespace mem
{
template <typename Mutex_> class lock_guard final {
public:
	//lock_guard()=default;
  lock_guard(Mutex_ *mt) : mt_(mt) { pthread_mutex_lock(mt_); }
  ~lock_guard() { pthread_mutex_unlock(mt_); }

public:
  lock_guard(const lock_guard &) = delete;
  lock_guard(lock_guard &&) = delete;
  lock_guard &operator=(const lock_guard &) = delete;
  lock_guard &operator=(lock_guard &&) = delete;

private:
  Mutex_ *mt_;
};
}
struct LockTest
{
int d;
std::mutex mt;
//pthread_mutex_t mt;
char buf[1024];
};
struct LockArr
{
LockTest lt[6];
};
LockArr *tmp = NULL;
std::mutex* init_shm(const key_t key)
{
    int shmid = shmget(key, sizeof(LockArr), 0666 | IPC_CREAT);
    if (shmid == -1)
    {
        return NULL;
    }

    void* shm_addr = shmat(shmid, NULL, 0);
    if (shm_addr == (void *) -1)
    {
        return NULL;
    }
 
    //pthread_mutexattr_t mutex_attr;
    //pthread_mutexattr_init(      &mutex_attr);
    //pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);
    //pthread_mutexattr_setrobust( &mutex_attr, PTHREAD_MUTEX_ROBUST);

    tmp = (LockArr *)shm_addr;
    std::mutex* _mutex = &tmp->lt[0].mt;
    //pthread_mutex_t* _mutex = &tmp->lt[0].mt;
    //pthread_mutex_init(_mutex,&mutex_attr);

    return _mutex;
}
#define PKEY 20181220
//process
std::mutex* pMutex = NULL;
void writemem(const unsigned char* data)
{
    if (pMutex == NULL)
    {
        pMutex = init_shm(PKEY);
    }

    std::lock_guard<std::mutex> l(*pMutex);
    //mem::lock_guard<pthread_mutex_t> pmt{pMutex};
    //pthread_mutex_lock(pMutex);

    //do something
    tmp->lt[0].buf[0] = 1;
    tmp->lt[0].buf[1] = 3;
    tmp->lt[0].buf[2] = 6;
    printf("lock successed--------------ooooooo--------------\n");
    usleep(10 * 1000 * 1000);


    //pthread_mutex_unlock(pMutex);
}
int main()
{
	unsigned char buf[1024] = {0};
        writemem(buf);
	return 0;
}

下面是读共享内存：

//recv
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <iostream>
#include <mutex>
namespace mem{
template <typename Mutex_> class lock_guard final {
public:
	//lock_guard()=default;
  lock_guard(Mutex_ *mt) : mt_(mt) { pthread_mutex_lock(mt_); }
  ~lock_guard() { pthread_mutex_unlock(mt_); }

public:
  lock_guard(const lock_guard &) = delete;
  lock_guard(lock_guard &&) = delete;
  lock_guard &operator=(const lock_guard &) = delete;
  lock_guard &operator=(lock_guard &&) = delete;

private:
  Mutex_ *mt_;
};
}
struct LockTest
{
int d;
std::mutex mt;
//pthread_mutex_t mt;
char buf[1024];
};
struct LockArr
{
LockTest lt[6];
};
LockArr *tmp = NULL;

/*pthread_mutex_t* */ std::mutex *init_shm(const key_t  key)
{
    int shmid = shmget( key, sizeof(LockArr), 0666 | IPC_CREAT);
    if (shmid == -1)
    {
        return NULL;
    }

    void* shm_addr = shmat(shmid, NULL, 0);
    if (shm_addr == (void *) -1)
    {
        return NULL;
    }
 
    //pthread_mutexattr_t mutex_attr;
    //pthread_mutexattr_init(      &mutex_attr);
    //pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);
    //pthread_mutexattr_setrobust( &mutex_attr, PTHREAD_MUTEX_ROBUST);

    tmp = (LockArr *)shm_addr;
    //pthread_mutex_t* _mutex  = &tmp->lt[0].mt;
    std::mutex* _mutex  = &tmp->lt[0].mt;
    //pthread_mutex_init(_mutex,&mutex_attr);

    return _mutex;
}
#define PKEY 20181220
//process
std::mutex* pMutex = NULL;
void readmem(const unsigned char* data)
{
    if (pMutex == NULL)
    {
        pMutex = init_shm(PKEY);
    }
    //lock_guard<pthread_mutex_t>(&pBuf->mt)
    //mem::lock_guard<pthread_mutex_t> pmt(pMutex);
    std::lock_guard<std::mutex> l(*pMutex);
    //pthread_mutex_lock(pMutex);

    //do something
    std::cout<<tmp->lt[0].buf[0]<<tmp->lt[0].buf[1]<<tmp->lt[0].buf[2]<<std::endl;

    printf("lock successed=======99999================\n");
    usleep(3 * 1000 * 1000);


    //pthread_mutex_unlock(pMutex);
}
int main()
{
	unsigned char buf[1024] = {0};
        readmem(buf);
	return 0;
}

目前这是用的标准库的std::mutex，如果将pthread_mutex_t放开并注释掉标准库的，也是没有问题的，但是得自己封装一个锁控制互斥体。
这里顺带说一个问题，看下面的代码：

//lock_guard<pthread_mutex_t>(&pBuf->mt);//这行代码OK
//lock_guard<pthread_mutex_t>(pMutex);//编译有问题
//lock_guard()=default;

上面两行代码都被注释了，第二行代码引入了下面第三行代码的出现（虽然增加第三行代码后可以编译通过），但它们是有问题的，之所以说有问题而不说错误，是因为从形式上讲编译器认为是正确的，但实际达不到目的。编译器报得错误和警告是：

error:candidate expects 1 argument, 0 provided
warning:parentheses were disambiguated as redundant parentheses around declaration of variable named

这引出一个基础的问题，声明一个匿名类对象时，如果使用一个具体的值来定义一个类，则没问题，如果是用一个同样值的变量来定义，编译器就无法确定此处是什么情况（是类对象定义还是函数声明），从而编译错误提出警告（如果后面级联调用对象内的变量或者函数同样没问题，编译器可以确定其为类对象定义）。解决的方法是要么直接采用新标准下的大括号即lock_guard<pthread_mutex_t>{pMutex}，要么如正常开发增加一个变量定义如正文中的代码所示。
共享内存中还有两个收尾的函数：

//共享内存从当前进程中分离，相当于shmat函数的反操作
int shmdt(const void *shmaddr);
//删除共享内存,这个其实有很多种用法，看command的标志
int shmctl(int shm_id, int command, struct shmid_ds *buf);

更细节的可以查看相关资料。

四、总结

在新的C++标准下，提供了很多新的锁，比如scoped_lock、shared_lock（对应的互斥体： timed_mutex、recursive_mutex、recursive_timed_mutex、shared_mutex、shared_timed_mutex）。还是要好好的看一看相关的锁的应用和跨进程中的使用的问题，没有实践就没有发言权。

fpcc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
共享内存在进程间应用

在新的C++标准下，提供了很多新的锁，比如scoped_lock、shared_lock（对应的互斥体： timed_mutex、recursive_mutex、recursive_timed_mutex、shared_mutex、shared_timed_mutex）。还是要好好的看一看相关的锁的应用和跨进程中的使用的问题，没有实践就没有发言权。
复制链接

扫一扫