Boost.Interprocess详解：跨进程通信与同步机制

4星 · 超过85%的资源需积分: 50 147 浏览量更新于2024-07-31 收藏 2.71MB PDF 举报

"Boost.Interprocess 是一个C++库，由Ion Gaztañaga创建并维护，旨在简化进程间通信和同步机制的使用。这个库提供了一系列功能，包括但不限于共享内存、内存映射文件、信号量、互斥锁、条件变量以及在共享内存和内存映射文件中的可升级互斥锁等。它还支持命名版本的同步对象，并允许用户自定义Boost.Interprocess的行为。" Boost.Interprocess是Boost库的一部分，主要设计用于不同进程间的通信和数据共享，而无需使用文件或网络接口。通过使用共享内存和内存映射文件，程序可以高效地在不同进程之间交换信息，这比传统的通过文件系统进行通信的方式更快且更节省资源。 1. **共享内存**：Boost.Interprocess提供了在多个进程间共享同一块内存区域的能力。这种方式可以避免频繁的磁盘I/O，提高数据传输速度。它使用`boost::interprocess::shared_memory_object`类来创建、访问和管理共享内存。 2. **内存映射文件**：内存映射文件允许将文件内容直接映射到进程的地址空间，使得文件操作类似于内存操作。`boost::interprocess::mapped_file_segment`类用于实现这一功能，它提供了读写文件内容的高效方式。 3. **同步机制**：Boost.Interprocess支持多种同步原语，如信号量、互斥锁、条件变量等，这些同步原语可以在共享内存和内存映射文件中使用，确保了在多进程环境下对共享数据的安全访问。例如，`boost::interprocess::mutex`和`boost::interprocess::condition_variable`用于实现线程间的同步。 4. **地址无关指针**：为了在不同的进程空间中使用同一块内存，Boost.Interprocess引入了`offset_ptr`，这是一个可以跨进程使用的智能指针，解决了不同进程间内存地址不一致的问题。 5. **管理的内存段**：库提供了`managed_memory_segment`类，它自动处理内存段的创建、销毁和分配，简化了内存管理。 6. **容器和内存分配算法**：Boost.Interprocess兼容标准模板库(STL)的容器，如`std::vector`和`std::list`，并且提供了一套适应于进程间通信的内存分配算法。 7. **直接I/O格式化**：库还包括`vectorstream`和`bufferstream`，它们允许直接在内存缓冲区中进行I/O操作，提高了效率。 8. **所有权智能指针**：如`boost::interprocess::shared_ptr`和`boost::interprocess::unique_ptr`，它们提供了智能指针的功能，确保对象在不再需要时被正确释放，特别是在多进程环境中。 9. **自定义Boost.Interprocess**：用户可以根据需求调整Boost.Interprocess的行为，比如定义自己的内存分配策略或者同步对象。 10. **文档和链接**：库附带详尽的参考文档，包括快速入门指南和深入的技术解释，以及有关作者、贡献者和相关资源的链接。通过利用Boost.Interprocess，开发者能够构建高性能的跨进程应用程序，实现进程间的高效通信和数据共享，同时保持代码的简洁性和可维护性。

#include <boost/interprocess/shared_memory_object.hpp>

#include <boost/interprocess/mapped_region.hpp>

#include <iostream>

#include <cstring>

int main ()

{

using namespace boost::interprocess;

try{

//Erase previous shared memory

shared_memory_object::remove("shared_memory");

//Create a shared memory object.

shared_memory_object shm (create_only, "shared_memory", read_write);

//Set size

shm.truncate(1000);

//Map the whole shared memory in this process

mapped_region region(shm, read_write);

//Write all the memory to 1

std::memset(region.get_address(), 1, region.get_size());

}

catch(interprocess_exception &ex){

shared_memory_object::remove("shared_memory");

std::cout << ex.what() << std::endl;

return 1;

}

return 0;

}

Now the client process:

Boost.Interprocess

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

#include <boost/interprocess/shared_memory_object.hpp>

#include <boost/interprocess/mapped_region.hpp>

#include <iostream>

#include <cstring>

int main ()

{

using namespace boost::interprocess;

shared_memory_object::remove("shared_memory");

try{

//Open already created shared memory object.

shared_memory_object shm (open_only, "shared_memory", read_only);

//Map the whole shared memory in this process

mapped_region region(shm, read_only);

//Check that memory was initialized to 1

const char *mem = static_cast<char*>(region.get_address());

for(std::size_t i = 0; i < region.get_size(); ++i){

if(*mem++ != 1){

std::cout << "Error checking memory!" << std::endl;

return 1;

}

std::cout << "Test successful!" << std::endl;

}

catch(interprocess_exception &ex){

std::cout << "Unexpected exception: " << ex.what() << std::endl;

shared_memory_object::remove("shared_memory");

return 1;

}

shared_memory_object::remove("shared_memory");

return 0;

}

Emulation for systems without shared memory objects

Boost.Interprocess provides portable shared memory in terms of POSIX semantics. Some operating systems don't support shared

memory as deﬁned by POSIX:

• Windows operating systems provide shared memory using memory backed by the paging ﬁle but the lifetime semantics are different

from the ones deﬁned by POSIX (see Native windows shared memory section for more information).

• Some UNIX systems don't support shared memory objects at all. MacOS is one of these operating systems.

In those platforms, shared memory is emulated with mapped ﬁles created in the temporary ﬁles directory. Because of this emulation,

shared memory has ﬁlesystem lifetime in those systems.

Removing shared memory

shared_memory_object provides a static remove function to remove a shared memory objects.

This function can fail if the shared memory objects does not exist or it's opened by another process. Note that this function is similar

to the standard C int remove(const char *path) function. In UNIX systems, shared_memory_object::remove calls

shm_unlink:

• The function will remove the name of the shared memory object named by the string pointed to by name.

• If one or more references to the shared memory object exist when is unlinked, the name will be removed before the function returns,

but the removal of the memory object contents will be postponed until all open and map references to the shared memory object

have been removed.

Boost.Interprocess

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

• Even if the object continues to exist after the last function call, reuse of the name will subsequently cause the creation of a

boost::interprocess::shared_memory_object instance to behave as if no shared memory object of this name exists (that

is, trying to open an object with that name will fail and an object of the same name can be created again).

In Windows operating systems, the function fails if the object is being used, so a programmer can't consider the UNIX behavior as

the portable behavior:

shared_memory_object::remove can fail if the shared memory is still in use, but this does not mean that it will fail if it's in use.

Just the same behavior as the standard C (stdio.h) int remove(const char *path) function.

Anonymous shared memory for UNIX systems

Creating a shared memory segment and mapping it can be a bit tedious when several processes are involved. When processes are

related via fork() operating system call in UNIX systems a simpler method is available using anonymous shared memory.

This feature has been implemented in UNIX systems mapping the device \dev\zero or just using the MAP_ANONYMOUS in a POSIX

conformant mmap system call.

This feature is wrapped in Boost.Interprocess using the anonymous_shared_memory() function, which returns a mapped_region

object holding an anonymous shared memory segment that can be shared by related processes.

Here is an example:

#include <boost/interprocess/anonymous_shared_memory.hpp>

#include <boost/interprocess/mapped_region.hpp>

#include <iostream>

#include <cstring>

int main ()

{

using namespace boost::interprocess;

try{

//Create an anonymous shared memory segment with size 1000

mapped_region region(anonymous_shared_memory(1000));

//Write all the memory to 1

std::memset(region.get_address(), 1, region.get_size());

//The segment is unmapped when "region" goes out of scope

}

catch(interprocess_exception &ex){

std::cout << ex.what() << std::endl;

return 1;

}

return 0;

}

Once the segment is created, a fork() call can be used so that region is used to communicate two related processes.

Native windows shared memory

Windows operating system also offers shared memory, but the lifetime of this shared memory is very different to kernel or ﬁlesystem

lifetime. The shared memory is created backed by the pageﬁle and it's automatically destroyed when the last process attached to the

shared memory is destroyed.

Because of this reason, there is no effective way to simulate kernel or ﬁlesystem persistence using native windows shared memory

and Boost.Interprocess emulates shared memory using memory mapped ﬁles. This assures portability between POSIX and Windows

operating systems.

Boost.Interprocess

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

However, accessing native windows shared memory is a common request of Boost.Interprocess users because they want to access

to shared memory created with other process that don't use Boost.Interprocess. In order to manage the native windows shared

memory Boost.Interprocess offers the windows_shared_memory class.

Windows shared memory creation is a bit different from portable shared memory creation: the size of the segment must be speciﬁed

when creating the object and can't be speciﬁed through truncate like with the shared memory object.

Take in care that when the last process attached to a shared memory is destroyed the shared memory is destroyed so there is no

persistency with native windows shared memory. Native windows shared memory has also another limitation: a process can open

and map the whole shared memory created by another process but it can't know which is the size of that memory. This limitation is

imposed by the Windows API so the user must somehow transmit the size of the segment to processes opening the segment.

Let's repeat the same example presented for the portable shared memory object: A server process creates a shared memory object,

maps it and initializes all the bytes to a value. After that, a client process opens the shared memory, maps it, and checks that the data

is correctly initialized. Take in care that if the server exits before the client connects to the shared memory the client connection

will fail, because the shared memory segment is destroyed when no processes are attached to the memory.

This is the server process:

#include <boost/interprocess/windows_shared_memory.hpp>

#include <boost/interprocess/mapped_region.hpp>

#include <iostream>

#include <cstring>

int main ()

{

using namespace boost::interprocess;

try{

//Create a native windows shared memory object.

windows_shared_memory shm (create_only, "shared_memory", read_write, 1000);

//Map the whole shared memory in this process

mapped_region region(shm, read_write);

//Write all the memory to 1

std::memset(region.get_address(), 1, 1000);

//Launch the client process and wait until finishes...

//...

}

catch(interprocess_exception &ex){

std::cout << ex.what() << std::endl;

return 1;

}

return 0;

}

Now, before destroying the windows_shared memory object, launch the client process:

Boost.Interprocess

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

#include <boost/interprocess/windows_shared_memory.hpp>

#include <boost/interprocess/mapped_region.hpp>

#include <iostream>

#include <cstring>

int main ()

{

using namespace boost::interprocess;

try{

//Open already created shared memory object.

windows_shared_memory shm(open_only, "shared_memory", read_only);

//Map the whole shared memory in this process

mapped_region region (shm, read_only);

//Check that memory was initialized to 1

const char *mem = static_cast<char*>(region.get_address());

for(std::size_t i = 0; i < 1000; ++i){

if(*mem++ != 1){

std::cout << "Error checking memory!" << std::endl;

return 1;

}

std::cout << "Test successful!" << std::endl;

}

catch(interprocess_exception &ex){

std::cout << "Unexpected exception: " << ex.what() << std::endl;

return 1;

}

return 0;

}

As we can see, native windows shared memory needs synchronization to make sure that the shared memory won't be destroyed before

the client is launched.

Memory Mapped Files

What is a memory mapped file?

File mapping is the association of a ﬁle's contents with a portion of the address space of a process. The system creates a ﬁle mapping

to associate the ﬁle and the address space of the process. A mapped region is the portion of address space that the process uses to

access the ﬁle's contents. A single ﬁle mapping can have several mapped regions, so that the user can associate parts of the ﬁle with

the address space of the process without mapping the entire ﬁle in the address space, since the ﬁle can be bigger than the whole address

space of the process (a 9GB DVD image ﬁle in a usual 32 bit systems). Processes read from and write to the ﬁle using pointers, just

like with dynamic memory. File mapping has the following advantages:

• Uniform resource use. Files and memory can be treated using the same functions.

• Automatic ﬁle data synchronization and cache from the OS.

• Reuse of C++ utilities (STL containers, algorithms) in ﬁles.

• Shared memory between two or more applications.

• Allows efﬁcient work with a large ﬁles, without mapping the whole ﬁle into memory

• If several processes use the same ﬁle mapping to create mapped regions of a ﬁle, each process' views contain identical copies of

the ﬁle on disk.

Boost.Interprocess

XML to PDF by RenderX XEP XSL-FO Formatter, visit us at http://www.renderx.com/

剩余549页未读，继续阅读

cleanfield

粉丝: 126
资源: 48

Boost.Interprocess详解：跨进程通信与同步机制

Boost.Interprocess：利用托管共享内存进行高效进程间通讯

boost interprocess

Microsoft C++ 异常: boost::interprocess::interprocess_exception

如何在共享内存创建boost::interprocess::interprocess_mutex 对象

boost lib 1.38.00 documentation pdf

highscore_boost,boost学习

Boost共享内存demo学习代码boost-1-80

Boost C++ 库

py_boost_shmem:在boost之间映射共享内存的示例

如何释放boost::interprocess::managed_shared_memory

最新资源