使用BOOST::Interprocess完成内存共享与同步

http://blog.csdn.net/turner_gao/article/details/51914848
http://blog.csdn.net/great3779/article/details/7226388
http://blog.csdn.net/great3779/article/details/7240271
http://blog.chinaunix.net/uid-28595538-id-5068065.html
匿名互斥量举例
想象两个进程需要往一个共享内存中的循环缓冲区中写入轨迹。每个进程都需要排他地访问这个循环缓冲区，并将轨迹写入，然后继续运行。

为了保护循环缓冲区，我们可以保存一个进程共享的互斥量在这里面。每个进程将在写数据之前锁定该互斥量，并且在写入轨迹后，写入一个标志。

定义一个头文件doc_anonymous_mutex_shared_data.hpp：

#include <boost/interprocess/sync/interprocess_mutex.hpp>struct shared_memory_log{enum { NumItems = 100 };enum { LineSize = 100 };shared_memory_log(): current_line(0),end_a(false),end_b(false){}boost::interprocess::interprocess_mutex mutex;char items[NumItems][LineSize];int current_line;bool end_a;bool end_b;}

下面是主进程，创建共享内存，构造循环缓冲区和写轨迹：

#include <boost/interprocess/shared_memory_object.hpp>#include <boost/interprocess/mapped_region.hpp>#include <boost/interprocess/sync/scoped_lock.hpp>#include “doc_anonymous_mutex_shared_data.hpp”#include <iostream>#include <cstdio>using namespace boost::interprocess;int main(){    try{        struct shm_remove        {        shm_remove() { shared_memory_object::remove(“MySharedMemory”);}        ~shm_remove() { shared_memory_object::remove(“MySharedMemory”);}    } remover;    shared_memory_object shm    ( create_only    ,”MySharedMemory”    ,read_write );    shm.truncate(sizeof(shared_memory_log));    mapped_region region( shm,read_write);//类封装时作为成员变量    void * addr = region.get_address();    shared_memory_log * data = new (addr) shared_memory_log;    for( int i=0;i<shared_memory_log::NumItems;++i ){        scoped_lock<interprocess_mutex> lock(data->mutex);        std::sprintf( data->items[(data->current_line++) % shared_memory_log::NumItems],”%s_%d”,”process_a”,i);        if( i==(shared_memory_log::NumItems-1) )        data->end_a = true;    }    // 等待另外一个进程结束    while( 1 ){        scoped_lock<interprocess_mutex> lock(data->mutex);        if( data->end_b)        break;    }}catch( interprocess_exception & ex ){    std::cout << ex.what() << std::endl;    return 1;}return 0;}

另外一个进程打开共享内存，获取权限访问循环缓冲区并开始写入轨迹。

#include <boost/interprocess/shared_memory_object.hpp>#include <boost/interprocess/mapped_region.hpp>#include <boost/interprocess/sync/scoped_lock.hpp>#include “doc_anonymous_mutex_shared_data.hpp”#include <iostream>#include <cstdio>using namespace boost::interprocess;int main(){    struct shm_remove{    ~shm_remove(){ shared_memory_object::remove(“MySharedMemory”);}} remover;shared_memory_object shm( open_only,”MySharedMemory”,read_write );mapped_region region( shm,read_write );//类封装时作为成员变量void * addr = region.get_address();shared_memory_log * data = static_cast<shared_memory_log*>(addr);for( int i=0;i<100;++i ){    scoped_lock<interprocess_mutex> lock(data->mutex);    std::sprintf(data->items[(data->current_line++)%shared_memory_log::NumItems]    ,”process_b_%d”,i);    if( i==(shared_memory_log::NumItems-1))    data->end_b = true;}while(1){scoped_lock<interprocess_mutex> lock(data->mutex);if( data->end_a)break;}return 0;}

正如我们看到的，互斥量在保护数据上非常实用，
类封装时，共享内存谁创建谁删除：

CShareMem::CShareMem(int iPlatForm/*=PLATE_SERVER*/):pShared_memory_data(NULL),iRegionSize(0),m_regionSer(NULL),m_regionCli(NULL),m_plateForm(iPlatForm){    switch (iPlatForm)    {    case PLATE_SERVER:        shared_memory_object::remove("SharedMemory");        break;    default:        break;    }}CShareMem::~CShareMem(void){    switch (m_plateForm)    {    case PLATE_SERVER:        shared_memory_object::remove("SharedMemory");        break;    default:        break;    }}