boost interprocess 进程通信

//共享内存

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")(89);
	TRACE("写入的内存值:%d\n",*i);
	std::pair pInt=managed_shdm.find("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")[4096](89);//此时初始化4096个int类型,但是分配的内存只有1024,construct会抛出异常
		if(i==0)
			return;
		TRACE("写入的内存值:%d\n",*i);
		std::pair pInt=managed_shdm.find("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")(89);
		if(i==0)
			return;
		TRACE("写入的内存值:%d\n",*i);
		//创建完毕了之后我们也可以进行销毁
		bool blDestroy=managed_shdm.destroy("Int");//blDestroy返回真表示销毁OK,否则就是没有找到销毁NG

		std::pair pInt=managed_shdm.find("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 ChaAllocator;
		//定义 新的一个string类,指定分配器
		typedef boost::interprocess::basic_string,ChaAllocator> newString;
		//查找并且构造一个 名称为 String ,默认值为Hello String Object的字符串
		newString* pS=managed_shdm.find_or_construct("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("Integer")(38); 
	managed_shdm.construct("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("Integer").first,*managed_shdm.find("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")();
		boost::interprocess::named_mutex mtex(boost::interprocess::open_or_create,"mtx");
		mtex.lock();//锁住
		++(*pI);//该内存析构不进行释放,那么每个应用程序启动就可以自增加1,达到写入同步的效果
		mtex.unlock();//解锁
		TRACE("%d\n",*managed_shdm.find("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")();
		//下面采用一种匿名的互斥对象
		boost::interprocess::interprocess_mutex *pmtx = managed_shdm.find_or_construct("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").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")();
		//下面采用一种匿名的互斥对象
		boost::interprocess::interprocess_mutex &mtex=*managed_shdm.find_or_construct("mtx1")();
		//下面采用一种有名的互斥对象
		//boost::interprocess::named_mutex mtex(boost::interprocess::open_or_create,"mtx1");//这是有名的互斥对象
		boost::interprocess::interprocess_condition& cnd=*managed_shdm.find_or_construct("cnd")();
		//下面采用一种有名的条件锁对象
		//boost::interprocess::named_condition cnd(boost::interprocess::open_or_create,"cnd1");
		//下面采用一种匿名的作用区域指针
		boost::interprocess::scoped_lock 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").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());
	}
}