我的目标是创建一个名为SharedMemory的模板单例类,它可以使用boost :: interprocess :: managed_shared_memory将给定的数据结构存储在共享内存中的映射中.
#ifndef SHARED_MEMORY_H_
#define SHARED_MEMORY_H_
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <functional>
#include <string>
#include <utility>
#include <map>
using namespace boost::interprocess;
template<typename T>
class SharedMemory {
typedef std::pair<std::string, T> ValueType;
typedef allocator<ValueType, managed_shared_memory::segment_manager>
ShmemAllocator;
typedef map<std::string, T, std::less<std::string>, ShmemAllocator> SharedMap;
public:
static SharedMemory<T>& instance();
void Create();
void Destory();
void insert(T* t);
std::map<std::string, T> getMapOfRecords();
private:
SharedMemory();
~SharedMemory(){delete m_segment;}
void Initialize();
managed_shared_memory* m_segment;
std::size_t m_size;
};
template<typename T>
inline void SharedMemory<T>::Create() {
Destory();
m_segment = new …我有2个进程共享一个由互斥和条件同步的队列.我在其中一个进程中有以下代码.
named_mutex mutex(open_only, "MyMutex");
int main()
{
while(1)
{
scoped_lock <named_mutex> lock(mutex)
//do some processing
}
}
我的问题是互斥锁是否在while循环中的所有调用中都有范围,还是每次while循环启动时都需要获取？互斥锁的范围是什么？似乎每次在while循环结束时互斥锁都会被解锁.
谢谢
我正在使用boost::interprocess::managed_shared_memory创建要跨进程共享的内存。
以下是采取的步骤：
步
a) Create memory.
步
a) Open memory.
b) Write to memory
步
a) Open memory.
b) Read from memory.
c) Open memory.
d) Read from memory.
e) Open memory.
f) Read from memory.
g) ...... and so on and so forth!
现在，问题是，在第 3 步中，我在阅读之前一遍又一遍地打开记忆！我认为这是多余的行为。
如何通过只打开一次来多次阅读？
实际上 open 命令在性能方面非常昂贵，这被证明是我的应用程序中的瓶颈。
后std::vector::resize()抛出一个std::bad_alloc异常,是原始数据仍然有效和可访问的std::vector对象？
答案是否适用于其他分配器,例如if boost::interprocess::allocator是否用作分配器,并且boost::interprocess::bad_alloc被抛出？
这让我感到沮丧.我只是想创建一个共享内存缓冲类,它在通过Boost.Interprocess创建的共享内存中使用,我可以在其中读取/存储数据.我写了以下内容来测试功能
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <iostream>
using namespace std;
using namespace boost::interprocess;
int main( int argc, char* argv[] ) {
shared_memory_object::remove( "MyName" );
// Create a shared memory object
shared_memory_object shm ( create_only, "MyName", read_write );
// Set size for the shared memory region
shm.truncate(1000);
// Map the whole shared memory in this process
mapped_region region(shm, read_write);
// Get pointer to the beginning of the mapped shared memory region
int* start_ptr;
start_ptr = static_cast<int*>(region.get_address());
// Write data into the …我试图了解boost进程库的工作原理.我有一个Equipment类,它在向量容器中保存整数值.
在父母进程中; 我在MySegmentObject段中构造了Equipment对象,在该对象的构造函数中,我在MySegmentVector段中创建了向量.
使用子进程; 我想访问创建的对象并获取向量的大小.我可以使用segment->find方法访问该对象,但是当我getSize()从被访问对象调用该方法时,它崩溃了!
我做错了什么,可能我错过了共享内存概念.
我测试了Visual Studio 2010上的代码并提升了1.43.0 lib
Equipments.h
#pragma once
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
using namespace boost::interprocess;
typedef boost::interprocess::allocator<int, managed_shared_memory::segment_manager> ShmemAllocator;
typedef boost::container::vector<int, ShmemAllocator> EqVector;
class Equipments {
public:
Equipments(void);
~Equipments(void);
void addEquipment(int n);
int getSize();
int getElement(int n);
private:
const ShmemAllocator *alloc_inst;
<offset_ptr>EqVector eqVector;
managed_shared_memory *segment;
};
Equipments.cpp
#include "StdAfx.h"
#include "Equipments.h"
#include <iostream>
Equipments::Equipments(void)
{
shared_memory_object::remove("mySegmentVector");
segment = new managed_shared_memory(create_only, "mySegmentObjectVector", 65536);
alloc_inst = new …我需要检查文件是否被锁定boost::interprocess::file_lock.我制作了这个,但我担心它会做什么:
bool DataCache::isLocked() const {
bool res = lock_->try_lock();
if(res)
lock_->unlock();
return res;
}
这是个好主意吗？有没有办法检查它而不锁定它？
我有2个进程:一个生产者和"消费者",它仍然将值保留在缓冲区中,它们将被覆盖.
但让消费者跟踪是一个问题.当缓冲区已满并且值被覆盖时,指向索引0的值是刚刚覆盖的值之前的值(即下一个最旧的值),刚刚插入的值是最后一个索引,移动所有值之间.
cb.push_back(0)
cb.push_back(1)
cb.push_back(2)
consumer reads to cb[1], cb[2] should == 2 when next read
cb.push_back(3)
cb[2] now == 1 effectively reading the old value
有趣的是在循环缓冲区迭代器也保持相同的值,即使在缓冲开始被改写,并除非阅读当你达到这样的工作好吗end()迭代器,它会永远等于end()甚至将更多的值之后迭代器,所以那么你必须std::prev(iter, 1)经过你已经完成了消费,然后当你插入更多的值后再次阅读,std::next(iter, 1)这样你就不会读取你已经读过的值.
我已经在这里待了好几天（甚至发布在 boost 论坛上）并且能够让第二个进程识别锁定的互斥锁似乎不起作用。请帮忙。这是代码：
一个常见的头文件：SharedObject.hpp
#ifndef SHAREDOBJECT_HPP
#define SHAREDOBJECT_HPP
#include <iostream>
#include <boost/interprocess/mapped_region.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/list.hpp>
#include <time.h>//for sleep
//--------for mutexes
#include <boost/interprocess/mapped_region.hpp>
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/sync/sharable_lock.hpp>
#include <boost/interprocess/sync/upgradable_lock.hpp>
#define MUTEX_SHARED_MEMORY_NAME "NavSharedMemoryMutex"
#define DATAOUTPUT "OutputFromObject"
#define INITIAL_MEM 650000
using namespace std;
namespace bip = boost::interprocess;
class SharedMutex
{
private:
typedef bip::interprocess_upgradable_mutex upgradable_mutex_type;
mutable upgradable_mutex_type mutex;
volatile int counter;
public:
void lockWithReadLock() const { bip::sharable_lock<upgradable_mutex_type> lock(mutex); }
void lockWithWriteLock() { bip::scoped_lock<upgradable_mutex_type> lock(mutex); }
};
//-------------------------------------- …