boost interprocess 进程通信

偏执的太偏执、 2022-06-05 05:55 304阅读 0赞

//共享内存
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	//boost::interprocess::open_or_create 打开或者创建一块新的共享内存
    	//"Hello":共享内存的名称
    	//boost::interprocess::read_write:该内存地址可以读写操作
    	boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_or_create,"Hello",boost::interprocess::read_write);
    	boost::interprocess::offset_t nSize=0;shdmem.get_size(nSize);
    	TRACE("%d\n",nSize);//获取共享内存的大小
    	shdmem.truncate(1024);//刚创建出来的内存大小是0,使用truncate分配1024个字节
    	TRACE("%s\n",shdmem.get_name());//获取共享内存的名称
    	shdmem.get_size(nSize);
    	TRACE("%d\n",nSize);//获取共享内存的大小
    	shdmem.remove(shdmem.get_name());//删除共享内存,如果不调用显示删除,则共享内存会一直在,析构函数不会析构
    }

//共享内存之mapped_region
    //mapped_region 可以不受分区根式的限制操作几G以上的文件,尤其是在32位系统
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	//boost::interprocess::open_or_create 打开或者创建一块新的共享内存
    	//"Hello":共享内存的名称
    	//boost::interprocess::read_write:该内存地址可以读写操作
    	boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_or_create,"Hello",boost::interprocess::read_write);
    	boost::interprocess::offset_t nSize=0;shdmem.get_size(nSize);
    	TRACE("%d\n",nSize);//获取共享内存的大小
    	shdmem.truncate(1024);//刚创建出来的内存大小是0,使用truncate分配1024个字节
    	//创建区域映射1,
    	//shdmem,绑定的共享内存对象
    	//boost::interprocess::read_write,指定区域读写操作
    	boost::interprocess::mapped_region mappedRe1(shdmem,boost::interprocess::read_write);
    	*(int*)mappedRe1.get_address()=68;//写入一个值
    	TRACE("%d,0x%x,%d\n",mappedRe1.get_size(),mappedRe1.get_address(),*(int*)mappedRe1.get_address());
    	//创建区域映射2
    	boost::interprocess::mapped_region mappedRe2(shdmem,boost::interprocess::read_only);
    	//shdmem,绑定的共享内存对象
    	//boost::interprocess::read_only,只读操作
    	TRACE("%d,0x%x,%d\n",mappedRe2.get_size(),mappedRe2.get_address(),*(int*)mappedRe1.get_address());//输出的地址得与mappedRe1不一致,但是值是一致的,一般情况同一块内存地址不会使用两块内存区域对象访问,这里只是演示
    
    	shdmem.remove(shdmem.get_name());//删除共享内存,如果不调用显示删除,则共享内存会一直在,析构函数不会析构
    }

//共享内存之remove_shared_memory_on_destroy,自动释放共享内存
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	{
    		boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_or_create,"Hello",boost::interprocess::read_write);
    
    		boost::interprocess::offset_t nSize;shdmem.get_size(nSize);
    		shdmem.truncate(1024);//设置一个共享内存大小
    
    		bool blRemo=boost::interprocess::shared_memory_object::remove("Hello");//使得 shdmem 在析构时自动删除共享内存
    		TRACE("%s\n",blRemo?"设置共享内存对象析构删除成功":"设置共享内存对象析构删除NG");
    	}
    	boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_or_create,"Hello",boost::interprocess::read_write);
    	boost::interprocess::offset_t nSize;shdmem.get_size(nSize);
    	TRACE("%d\n",nSize);//如果一个新的共享内存构造的话,这里打印出来应该是0,如果不是0表示第一个操作未删除共享内存
    }

//共享内存之windows_shared_memory
    //一种特别的共享内存,在windows 系统使用,最后一个应用程序终止时会自动删除共享内存,构造时候就得确认大小,没有truncate函数
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	//boost::interprocess::open_or_create,内存存在则打开,不存在则创建
    	//"Hello Windows",创建的共享内存名称
    	//boost::interprocess::read_write,指定读写操作
    	//8192,指定共享内存大小,如果这个值低于windows_shared_memory预设值,则以windows_shared_memory预设值为分配大小,比如设置1024,windows_shared_memory预设值是4086,则分配4086,否则以1024分配
    	boost::interprocess::windows_shared_memory wshd(boost::interprocess::open_or_create,"Hello Windows",boost::interprocess::read_write,8192);
    	TRACE("%d\n",wshd.get_size());
    	boost::interprocess::mapped_region mappedRe1(wshd,boost::interprocess::read_write);
    	*(int*)mappedRe1.get_address()=89;
    	TRACE("%d,0x%x,%d\n",mappedRe1.get_size(),mappedRe1.get_address(),*(int*)mappedRe1.get_address());
    	boost::interprocess::mapped_region mappedRe2(wshd,boost::interprocess::read_only);
    	TRACE("%d,0x%x,%d\n",mappedRe2.get_size(),mappedRe2.get_address(),*(int*)mappedRe2.get_address());
    }

boost::interprocess::shared_memory_object::remove("Hello");
    	boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello",1024);
    	//如果给定名称的对象已经在托管的共享内存中存在，那么 construct() 将会失败。 在这种情况下，construct() 返回值是0
    	//find_or_construct 也可以使用这个,如果存在则设置值,否则就和construct一致
    	int *i=managed_shdm.construct<int>("Int")(89);
    	TRACE("写入的内存值:%d\n",*i);
    	std::pair<int*,std::size_t> pInt=managed_shdm.find<int>("Int");//可以通过名称查找指定的内存地址值,第二个值是数组的大小
    	TRACE("查找出来的内存值,%d,数组大小,%d\n",*pInt.first,pInt.second);

try
    	{
    		boost::interprocess::shared_memory_object::remove("Hello");
    		boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello",1024);
    		//如果给定名称的对象已经在托管的共享内存中存在，那么 construct() 将会失败。 在这种情况下，construct() 返回值是0
    		//find_or_construct 也可以使用这个,如果存在则设置值,否则就和construct一致
    		int *i=managed_shdm.construct<int>("Int")[4096](89);//此时初始化4096个int类型,但是分配的内存只有1024,construct会抛出异常
    		if(i==0)
    			return;
    		TRACE("写入的内存值:%d\n",*i);
    		std::pair<int*,std::size_t> pInt=managed_shdm.find<int>("Int");//可以通过名称查找指定的内存地址值,第二个值是数组的大小
    		TRACE("查找出来的内存值,%d,数组大小,%d\n",*pInt.first,pInt.second);
    	}
    	catch (std::exception& e)
    	{
    		TRACE("%s\n",e.what());//输出,boost::interprocess::bad_alloc
    	}

try
    	{
    		boost::interprocess::shared_memory_object::remove("Hello");
    		boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello",1024);
    		//如果给定名称的对象已经在托管的共享内存中存在，那么 construct() 将会失败。 在这种情况下，construct() 返回值是0
    		//find_or_construct 也可以使用这个,如果存在则设置值,否则就和construct一致
    		int *i=managed_shdm.construct<int>("Int")(89);
    		if(i==0)
    			return;
    		TRACE("写入的内存值:%d\n",*i);
    		//创建完毕了之后我们也可以进行销毁
    		bool blDestroy=managed_shdm.destroy<int>("Int");//blDestroy返回真表示销毁OK,否则就是没有找到销毁NG
    
    		std::pair<int*,std::size_t> pInt=managed_shdm.find<int>("Int");//可以通过名称查找指定的内存地址值,第二个值是数组的大小
    		if(0==pInt.first){
    			TRACE("无法找到对应的内存\n");
    			return;
    		}
    		TRACE("查找出来的内存值,%d,数组大小,%d\n",*pInt.first,pInt.second);
    	}
    	catch (std::exception& e)
    	{
    		TRACE("%s\n",e.what());//输出,boost::interprocess::bad_alloc
    	}

//托管内存之托管内存对象
    //创建和管理共享的 boost::interprocess::shared_memory_object 
    //许多C++标准模板库的实现并不太灵活，不能够提供 Boost.Interprocess 使用 std::string 或 std::list 的容器
    //为了允许开发人员可以使用这些有名的来自C++标准的容器，Boost.Interprocess 在命名空间 boost::interprocess 下，提供了它们的更灵活的实现方式
    //，boost::interprocess::string 的行为实际上对应的是 std::string，优点是它的对象能够安全地存储在托管共享内存上
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	try
    	{
    		boost::interprocess::shared_memory_object::remove("Hello");
    		boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello",1024);
    		//定义 分段内存托管 分配器
    		typedef boost::interprocess::allocator<char,boost::interprocess::managed_shared_memory::segment_manager> ChaAllocator;
    		//定义 新的一个string类,指定分配器
    		typedef boost::interprocess::basic_string<char,std::char_traits<char>,ChaAllocator> newString;
    		//查找并且构造一个 名称为 String ,默认值为Hello String Object的字符串
    		newString* pS=managed_shdm.find_or_construct<newString>("String")("Hello String Object",managed_shdm.get_segment_manager());
    		pS->insert(pS->size(),",this is a new~");//插入新的字符串
    		TRACE("%s\n",pS->c_str());
    	}
    	catch (std::exception& e)
    	{
    		TRACE("%s\n",e.what());//输出,boost::interprocess::bad_alloc
    	}
    	/*
    	与 boost::interprocess::string 一起, Boost.Interprocess 还提供了许多其他C++标准中已知的容器。 
    	如, boost::interprocess::vector 和 boost::interprocess::map，分别定义在 boost/interprocess/containers/vector.hpp 和 boost/interprocess/containers/map.hpp文件中
    	*/
    }

//托管内存之托管内存对象之atomic_func
    //如果两个应用程序尝试在托管共享内存上创建不同名称的对象，访问相应地被串行化了。 为了立刻执行多个操作而不被其他应用程序的操作打断，可以使用 atomic_func() 函数
    
    void construct_objects(boost::interprocess::managed_shared_memory& managed_shdm){
    	managed_shdm.construct<int>("Integer")(38); 
    	managed_shdm.construct<float>("Float")(3.14); 
    }
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	try
    	{
    		boost::interprocess::shared_memory_object::remove("Hello");
    		boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello",1024);
    		managed_shdm.atomic_func(boost::bind(construct_objects,boost::ref(managed_shdm)));
    		TRACE("%d,%f\n",*managed_shdm.find<int>("Integer").first,*managed_shdm.find<float>("Float").first);
    	}
    	catch (std::exception& e)
    	{
    		TRACE("%s\n",e.what());
    	}
    }

//共享内存之托管内存之同步
    //boost::interprocess::named_mutex
    
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	try
    	{
    		//boost::interprocess::shared_memory_object::remove("Hello");
    		boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello",1024);
    		int* pI=managed_shdm.find_or_construct<int>("Int")();
    		boost::interprocess::named_mutex mtex(boost::interprocess::open_or_create,"mtx");
    		mtex.lock();//锁住
    		++(*pI);//该内存析构不进行释放,那么每个应用程序启动就可以自增加1,达到写入同步的效果
    		mtex.unlock();//解锁
    		TRACE("%d\n",*managed_shdm.find<int>("Int").first);
    	}
    	catch (std::exception& e)
    	{
    		TRACE("%s\n",e.what());
    	}
    }

//共享内存之托管内存之同步
    //boost::interprocess::interprocess_mutex 匿名互斥对象
    
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	try
    	{
    		//boost::interprocess::shared_memory_object::remove("Hello");
    		boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello",1024);
    		int* pI=managed_shdm.find_or_construct<int>("Int")();
    		//下面采用一种匿名的互斥对象
    		boost::interprocess::interprocess_mutex *pmtx = managed_shdm.find_or_construct<boost::interprocess::interprocess_mutex>("mtx")(); 
    		//boost::interprocess::named_mutex mtex(boost::interprocess::open_or_create,"mtx");//这是有名的互斥对象
    		
    		pmtx->lock();//锁住,使得多个应用程序只能有一个才能访问
    		++(*pI);//该内存析构不进行释放,那么每个应用程序启动就可以自增加1,达到写入同步的效果
    		pmtx->unlock();//解锁
    		TRACE("%d\n",*managed_shdm.find<int>("Int").first);
    	}
    	catch (std::exception& e)
    	{
    		TRACE("%s\n",e.what());
    	}
    }

//共享内存之托管内存之同步
    //boost::interprocess::interprocess_condition 匿名条件锁
    //
    
    
    void CMFC08Dlg::OnBnClickedButton2()
    {
    	//
    	try
    	{
    		boost::interprocess::shared_memory_object::remove("Hello");
    		boost::interprocess::managed_shared_memory managed_shdm(boost::interprocess::open_or_create,"Hello1",1024);
    		int* pI=managed_shdm.find_or_construct<int>("Int")();
    		//下面采用一种匿名的互斥对象
    		boost::interprocess::interprocess_mutex &mtex=*managed_shdm.find_or_construct<boost::interprocess::interprocess_mutex>("mtx1")();
    		//下面采用一种有名的互斥对象
    		//boost::interprocess::named_mutex mtex(boost::interprocess::open_or_create,"mtx1");//这是有名的互斥对象
    		boost::interprocess::interprocess_condition& cnd=*managed_shdm.find_or_construct<boost::interprocess::interprocess_condition>("cnd")();
    		//下面采用一种有名的条件锁对象
    		//boost::interprocess::named_condition cnd(boost::interprocess::open_or_create,"cnd1");
    		//下面采用一种匿名的作用区域指针
    		boost::interprocess::scoped_lock<boost::interprocess::interprocess_mutex> lock(mtex);//构造并且进行锁住
    		while (*pI<10)
    		{
    			if (*pI % 2==0)
    			{
    				++(*pI);
    				cnd.notify_all();//通知
    				cnd.wait(lock);//释放占有权,并且等待下一次通知,以及上锁
    			}else{
    				TRACE("%d\n",*pI);//输出当前的值
    				++(*pI);
    				cnd.notify_all();//通知
    				cnd.wait(lock);//释放占有权,并且等待下一次通知,以及上锁
    			}
    		}
    		cnd.notify_all();//通知所有
    		TRACE("%d\n",*managed_shdm.find<int>("Int").first);
    		//释放
    		boost::interprocess::shared_memory_object::remove("Hello1");
    		boost::interprocess::named_mutex::remove("mtx1");
    		boost::interprocess::named_condition::remove("cnd1");
    		//最后lock在析构的时候会解锁,所以在其他进程wait也会等待响应
    
    	}
    	catch (std::exception& e)
    	{
    		TRACE("%s\n",e.what());
    	}
    }