boost interprocess 进程通信

最新推荐文章于 2023-12-04 11:47:43 发布
最新推荐文章于 2023-12-04 11:47:43 发布
阅读量5.2k 收藏 5
点赞数 3
分类专栏： Boost
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengzhisuoliu/article/details/78576757
版权 
//共享内存

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());
	}
}


mengzhisuoliu
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Boost：多进程间通过信号量同步
风静如云的博客
12-02 254
Boot可以通过信号量boost::interprocess::interprocess_semaphore进行多进程间的同步。最大阻塞时间式等待：timed_wait(const boost::posix_time::ptime&abs_time);介绍了如何在多进程间共享内存，既然是共享内存，那么久存在竞争的问题。可以看到，两个进程通过信号量完成了读写的同步。其中构造参数0，用于初始化信号量的初始值。非阻塞式等待：try_wait();阻塞式等待：wait();
Boost：多进程间消息队列通信
风静如云的博客
12-03 311
100 //消息队列的长度。,sizeof(int) //单个消息的大小。,"message_queue" //消息队列的名字。可见接收到了消息队列中的内容，并且会优先接收优先级为1的消息。先后运行s5密爱哦中后再运行r。参数2：接收消息缓存区的大小。参数3：接收到的消息的大小。参数1：发送的数据的指针。参数1：接收消息的指针。
Boost库进程通信
zy1024的博客
06-18 1152
1.Boost.Interprocess和Boost.Asio库 1）Boost.Interprocess库，它包括众多的类，这些类提供了操作系统相关的进程间通讯接口的抽象层。 2）如果同一台计算机不同进程之间通信，虽然也可考虑选择Boost.Asio，但是性能方面不如Boost.Interprocess，因为Boost.Interprocess是使用操作系统的功能优化了同一台计算机不同进程...
Boost 15 进程间通信
turner_gao的专栏
07-15 7499
1.介绍 Boost.Interprocess库简化了使用通用的进程间通信和同步机制。并且提供这些机制的部件： * 共享内存 * 内存映射文件 * 信号量，互斥量，条件变量和可升级的互斥量类型，该类型可以放入共享内存和内存映射文件中 * 命名版本的同步对象 * 文件锁 * 相对指针 * 消息队列 Boost.Interprocess还提供了更高级的进程间机制...
【C++】开源：Boost进程间通信库InterProcess配置使用
最新发布
DevFrank的博客
12-04 1037
Boost进程间通信库InterProcess配置使用
boost::interprocess 进程间通信之消息队列的实现
a1534219218的博客
10-10 1198
1. 首先需要建立两个工程，processA, ProcessB 2. 写一个消息队列的类，"Condition_shared_data.hpp" #include <boost/interprocess/detail/config_begin.hpp> #include <boost/interprocess/sync/interprocess_mutex.h...
C++ 进程间通信 详解1
GIS摆渡人
05-24 449
一，C++ 常用进程间通信 管道(Pipe)：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。命名管道(named pipe)：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。信号(Signal)：信号是比较复杂的...
C++ Boost提供的六种进程间通信技术介绍
琅嬛福地
12-01 1159
内存映射文件（Memory-Mapped Files）是一种进程间通信（IPC）机制，允许文件或设备（通常是磁盘上的文件）的内容被映射到进程的地址空间。这样，文件可以像访问常规内存数组一样被访问，而不是使用传统的文件读写API。这种技术不仅可以用于文件I/O，还经常用于进程间的共享内存。以下是内存映射文件工作原理的概述：文件映射文件打开：首先，需要有一个文件。这个文件可以是已存在的，也可以是新创建的，用于将数据持久存储到磁盘。创建映射：操作系统提供了创建内存映射的API。
boost中interprocess使用方法介绍（未完待续）
doushuopeng的博客
04-05 2742
介绍： Boost.Interprocess 简化了进程间通信和同步机制，并且提供了很多方式方法： 共享内存 内存文件映射 用于共享内存和内存文件映射中的Semaphores、mutexes、Condition variables和upgradable mutex 命名版本的同步机制，类似于unix\windows中的sem_open\createSemaphore API 文件锁 相关指针 消息队列 Boost.Interprocess 还提供了高级的进程间通信机制来动态分配共享内存和内存
boost_interprocess.7z
07-08
Boost.Interprocess 是 Boost 库中的一个重要组件，它为跨进程的通信和共享内存提供了高效且灵活的解决方案。这个开源库支持多种方式进行进程间通信（IPC），使得不同进程间的数据交换变得更加简单。本文将深入探讨 ...
Boost.Interprocess介绍
02-25
Boost.Interprocess实现了进程内线程的同步通信机制，包括共享内存操作
父子进程通信
10-28
本文将深入探讨“父子进程通信”这一主题，包括共享消息、文件映射以及消息通信等核心知识点，并以C++语言实现的图形界面为例进行解析。 首先，我们来理解“父子进程”。在操作系统中，一个进程可以创建新的进程，...
C++使用共享内存 进程通信
05-02
在IT领域，进程通信是多进程系统中一个关键的概念，特别是在分布式系统或并发编程中。C++作为一种强大的编程语言，提供了多种方式实现进程间的通信，其中包括共享内存。共享内存允许两个或更多的进程直接读写同一块...
进程间通信.rar
10-22
如果需要简单的父子进程通信，无名管道就足够了；如果需要在不相关进程间通信，或者通信涉及网络，那么套接字更适合。 在"进程间通信.rar"这个压缩包中，可能包含有实现这些通信方式的C++代码示例。通过阅读和学习...
boost 异常处理
是我
11-24 6905
#include #include //Boost.System boost::system::error_code ec; string hostname=boost::asio::ip::host_name(ec); TRACE("%d\n",ec.value());//错误代码等于0表示OK,否则则是错误代码的编号 TRACE("%s\n",ec.category(
boost使用总结
是我
11-15 4752
1.boost::variant boost::variant v; v=3.14; v='a'; v="jks";//最后压入了string double v1=boost::get(v);//这里会抛出一个异常,boost::variant 以最后一个为准 char v2=boost::get(v); string v3=boost::get(v); boost::varian
boost Filesystem 文件系统
是我
11-20 860
boost::filesystem::path p("C:\\Windows\\System");//这里实际上不会访问文件系统的内容以及路径,仅仅是一个字符串而已 TRACE("%s\n",p.root_name().string().c_str());//这里输出C: TRACE("%s\n",p.root_directory().string().c_str());//返回"\" TR
boost 多线程
是我
11-16 742
void wait(int seconds){ boost::this_thread::sleep(boost::posix_time::seconds(seconds));//休眠秒数 } void boost_thread(){ //新的线程创建 TRACE("当前线程ID,%d\n",GetCurrentThreadId()); for (int i=0;i<5;i++) {
boost interprocess
05-05
Boost.Interprocess 是一个 C++ 库，提供了一些跨进程通信和共享内存的封装，使得程序员可以方便地在不同进程之间共享数据。它提供了一些常见的共享内存和互斥量等同步机制，支持多个操作系统和平台。 Boost.Interprocess 可以帮助开发者实现高效的 IPC 通信，因为共享内存可以避免数据在不同进程之间的复制，从而提高性能。与其它 IPC 通信方式相比，共享内存具有低延迟和高吞吐量的优势。 Boost.Interprocess 的主要功能和组件包括： - 共享内存：提供了一些类，可以在不同进程之间共享内存。 - 互斥量和锁：提供了一些类，可以在共享内存中实现同步和互斥。 - 消息队列：提供了一些类，可以在不同进程之间发送和接收消息。 - 文件映射：提供了一些类，可以将文件映射到内存中，实现文件的共享和访问。 总之，Boost.Interprocess 是一个非常有用的 C++ 库，可以帮助开发者实现高效的 IPC 通信和共享内存。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值