XMD

无语

QSharedMemory介绍与使用

发表于 更新于 分类于
本文字数： 8.5k 阅读时长 ≈ 8 分钟

来自Gemini

QSharedMemory 详细介绍

QSharedMemory 类允许在不同的进程之间共享内存。它提供了跨进程通信的一种高效方式，避免了复制数据的开销。

成员函数：

  • create()：创建或打开一个共享内存段。
  • attach()：将进程附加到现有的共享内存段。
  • detach()：从共享内存段分离进程。
  • lock()：锁定共享内存段以进行读写。
  • unlock()：解锁共享内存段。
  • data()：返回指向共享内存段数据的指针。
  • size()：返回共享内存段的大小。

具体使用：

创建和附加共享内存段：
1
2
3
4
5
6
7
8
9
10
11
12
13
// 创建一个名为 "my_shared_memory" 的共享内存段
QSharedMemory sharedMemory;
sharedMemory.setKey("my_shared_memory");
if (!sharedMemory.create(1024)) {
    // 创建失败
}

// 附加到现有的共享内存段
QSharedMemory sharedMemory2;
sharedMemory2.setKey("my_shared_memory");
if (!sharedMemory2.attach()) {
    // 附加失败
}
读写共享内存段：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 锁定共享内存段
sharedMemory.lock();

// 写入数据
char *data = sharedMemory.data();
strcpy(data, "Hello, world!");

// 解锁共享内存段
sharedMemory.unlock();

// 从共享内存段读取数据
sharedMemory2.lock();
char *data2 = sharedMemory2.data();
qDebug() << data2; // 输出："Hello, world!"
sharedMemory2.unlock();

注意事项：

  • 共享内存段的键必须在所有进程中相同。
  • 必须在使用共享内存段之前锁定它。
  • 确保在完成共享内存段操作后将其解锁。
  • 共享内存段的大小必须足以容纳要共享的数据。
  • 进程必须具有读取和写入共享内存段的权限。

示例：

以下是一个使用 QSharedMemory 在两个进程之间共享字符串的示例：

进程 1：

1
2
3
4
5
6
7
8
9
10
QSharedMemory sharedMemory;
sharedMemory.setKey("my_shared_memory");
if (!sharedMemory.create(1024)) {
    // 创建失败
}

sharedMemory.lock();
char *data = sharedMemory.data();
strcpy(data, "Hello, world!");
sharedMemory.unlock();

进程 2：

1
2
3
4
5
6
7
8
9
10
QSharedMemory sharedMemory;
sharedMemory.setKey("my_shared_memory");
if (!sharedMemory.attach()) {
    // 附加失败
}

sharedMemory.lock();
char *data = sharedMemory.data();
qDebug() << data; // 输出："Hello, world!"
sharedMemory.unlock();

在进程 1 中创建共享内存段并写入数据后，进程 2 可以附加到该共享内存段并读取数据。

chatgpt

QSharedMemory 是 Qt 提供的用于在进程之间共享内存的类。它允许多个进程在同一台计算机上共享数据，而无需使用网络或文件系统等外部通信机制。以下是关于 QSharedMemory 的详细介绍和具体使用方法：

详细介绍：

  1. 创建和绑定： 使用 setKey() 方法来设置共享内存的唯一键值，然后使用 create() 方法创建共享内存，或者使用 attach() 方法绑定到现有的共享内存。

  2. 读写操作： 通过 lock() 和 unlock() 方法对共享内存进行锁定和解锁，然后可以像操作普通内存一样进行读写操作。

  3. 数据传输： 你可以使用 constData() 方法来获取共享内存的常量数据指针，然后通过指针进行数据的读取操作。如果需要修改共享内存中的数据，需要先调用 data() 方法获取可修改的数据指针。

  4. 清理和释放： 在使用完共享内存后，需要调用 detach() 方法解除与共享内存的绑定，并且可以选择调用 remove() 方法来彻底删除共享内存。

具体使用方法：

写入数据到共享内存：

1
2
3
4
5
6
7
8
9
10
11
QSharedMemory sharedMemory;
sharedMemory.setKey("MySharedMemory");

if (!sharedMemory.create(sizeof(int))) {
    // 创建共享内存失败
}

sharedMemory.lock();
int *data = static_cast<int *>(sharedMemory.data());
*data = 42; // 写入数据
sharedMemory.unlock();

从共享内存中读取数据：

1
2
3
4
5
6
7
8
9
10
11
QSharedMemory sharedMemory;
sharedMemory.setKey("MySharedMemory");

if (!sharedMemory.attach()) {
    // 绑定共享内存失败
}

sharedMemory.lock();
int *data = static_cast<int *>(sharedMemory.data());
int value = *data; // 读取数据
sharedMemory.unlock();

清理和释放共享内存：

1
2
3
4
5
6
7
QSharedMemory sharedMemory;
sharedMemory.setKey("MySharedMemory");

if (sharedMemory.attach()) {
    sharedMemory.detach(); // 解绑共享内存
    sharedMemory.remove(); // 删除共享内存
}

通过使用 QSharedMemory，你可以轻松地实现进程之间的数据共享，但需要注意在使用时确保数据的一致性和安全性，避免出现竞态条件和数据损坏。

来自copilot

QSharedMemory 是 Qt 框架中用于实现多线程和多进程之间共享内存的类。它提供了一种安全的方式来在不同线程或进程之间共享数据。让我们详细了解一下 QSharedMemory 的使用方法和一些关键概念。

概述

QSharedMemory 允许多个线程和进程访问共享内存段，并提供了一种方法，让单个线程或进程锁定内存以进行独占访问。需要注意的是，不同平台（如 Windows、Unix 和 HP-UX）对 QSharedMemory 的行为有一些差异，我们将在下面详细介绍。

  1. Windows 平台：
    • QSharedMemory 不“拥有”共享内存段。当所有连接到特定共享内存段的 QSharedMemory 实例的线程或进程销毁其实例或退出时，Windows 内核会自动释放共享内存段。
  2. Unix 平台：
    • QSharedMemory “拥有”共享内存段。当将 QSharedMemory 实例附加到特定共享内存段的最后一个线程或进程通过销毁其实例与该段分离时，Unix 内核会释放共享内存段。
    • 如果最后一个线程或进程在没有运行 QSharedMemory 析构函数的情况下崩溃，共享内存段会在崩溃中幸存下来。
  3. HP-UX 平台：
    • 每个进程只允许一个连接到共享内存段。因此，QSharedMemory 不应跨 HP-UX 中同一进程中的多个线程使用。
    • 在对共享内存进行读写之前，务必使用 lock() 锁住共享内存，完成后使用 unlock() 释放锁。

成员方法

以下是 QSharedMemory 类的一些常用成员方法：

  1. QSharedMemory::QSharedMemory(const QString &key, QObject *parent = nullptr)：
    • 使用给定的父对象构造一个共享内存对象，并将其键设置为 key。因为设置了键，可以调用 create() 和 attach() 函数。
  2. QSharedMemory::QSharedMemory(QObject *parent = nullptr)：
    • 此函数重载，使用给定的父对象构造一个共享内存对象。共享内存对象的键不是由构造函数设置的，因此在调用 create() 或 attach() 之前必须使用 setKey() 或 setNativeKey() 设置键。
  3. QSharedMemory::~QSharedMemory()：
    • 析构函数清除键，强制共享内存对象与其底层共享内存段分离。如果此共享内存对象是最后一个连接到共享内存段的对象，则 detach() 操作会销毁共享内存段。
  4. bool QSharedMemory::attach(QSharedMemory::AccessMode mode = ReadWrite)：
    • 尝试将进程关联到由传递给构造函数或调用 setKey() 或 setNativeKey() 的密钥标识的共享内存段。访问方式默认为 ReadWrite，也可以是 ReadOnly。
    • 附加共享内存段后，可以通过调用 data() 获得共享内存的指针。
  5. const void *QSharedMemory::constData() const：
    • 返回一个指向共享内存段内容的常量指针，如果有的话。记得在对共享内存进行读写之前用 lock() 锁住共享内存，完成后记得用 unlock() 释放锁。
  6. bool QSharedMemory::create(int size, QSharedMemory::AccessMode mode = ReadWrite)：
    • 使用传递给构造函数的键创建大小为 size 字节的共享内存段，然后使用给定的访问模式关联到新的共享内存段并返回 `

​

QSharedMemory 的使用场景

QSharedMemory 是 Qt 提供的用于不同进程间共享内存的类。它允许在多个进程间共享一块内存区域，而无需通过网络或文件进行数据传递。典型的使用场景包括：

  1. 进程间通信（IPC）：多个进程需要共享数据时，QSharedMemory 提供了高效的内存共享方式，避免了文件I/O和网络传输的开销。常见的应用包括分布式系统、服务器和客户端之间的通信。

  2. 数据传递：在高性能场景下，一个进程可以将大块数据写入共享内存，另一个进程可以直接读取该数据，而不必经过复杂的序列化和反序列化。

  3. 多进程并发应用：对于并发应用，QSharedMemory 可以用来共享状态数据，如进度、设置、缓存等信息。多个进程可以同时访问该共享数据，并基于该数据进行不同的操作。

  4. 避免进程重复启动：可以通过共享内存实现单例模式来避免同一个应用程序的多次启动。启动时检查共享内存是否已存在，如果存在则不再创建新进程。

  5. 实时系统：在需要实时交换数据的系统中，如多媒体处理、传感器数据收集等，QSharedMemory 可以实现多个进程之间快速、低延迟的数据交换。

使用 QSharedMemory 需要注意同步问题，比如防止多个进程同时访问共享内存而导致数据竞争，因此通常需要结合一些同步机制（如 QMutex）来保证数据的一致性和正确性。

示例

以下是一个使用 QSharedMemory 的简单示例，演示如何在两个进程之间共享数据。该示例分为两个部分：一个进程写入共享内存，另一个进程从共享内存中读取数据。

1. 写入进程（Writer）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <QCoreApplication>
#include <QSharedMemory>
#include <QBuffer>
#include <QDataStream>
#include <QDebug>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    // 创建一个共享内存对象
    QSharedMemory sharedMemory("SharedMemoryExample");

    // 如果共享内存已经存在，先分离
    if (sharedMemory.isAttached()) {
        sharedMemory.detach();
    }

    // 分配共享内存，大小为 1024 字节
    if (!sharedMemory.create(1024)) {
        qDebug() << "Unable to create shared memory segment.";
        return 1;
    }

    // 准备要写入的数据
    QByteArray data;
    QBuffer buffer(&data);
    buffer.open(QBuffer::WriteOnly);
    QDataStream out(&buffer);
    out << QString("Hello from writer!");

    // 将数据写入共享内存
    sharedMemory.lock();  // 加锁以确保写入过程的安全
    char *to = (char*)sharedMemory.data();
    const char *from = data.data();
    memcpy(to, from, qMin(sharedMemory.size(), data.size()));
    sharedMemory.unlock();  // 解锁

    qDebug() << "Data written to shared memory.";

    return a.exec();
}

2. 读取进程（Reader）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <QCoreApplication>
#include <QSharedMemory>
#include <QBuffer>
#include <QDataStream>
#include <QDebug>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    // 连接到共享内存对象
    QSharedMemory sharedMemory("SharedMemoryExample");

    if (!sharedMemory.attach()) {
        qDebug() << "Unable to attach to shared memory segment.";
        return 1;
    }

    // 读取共享内存中的数据
    sharedMemory.lock();  // 加锁以确保读取过程的安全
    QByteArray data;
    data.resize(sharedMemory.size());
    const char *from = (const char*)sharedMemory.constData();
    memcpy(data.data(), from, qMin(sharedMemory.size(), data.size()));
    sharedMemory.unlock();  // 解锁

    // 解码数据
    QBuffer buffer(&data);
    buffer.open(QBuffer::ReadOnly);
    QDataStream in(&buffer);
    QString message;
    in >> message;

    qDebug() << "Data read from shared memory:" << message;

    return a.exec();
}

运行步骤

  1. 启动写入进程：首先运行写入进程，它将把 “Hello from writer!” 写入共享内存。
  2. 启动读取进程：然后运行读取进程，它会从共享内存中读取该消息并打印出来。

关键点

  • QSharedMemory::create() 用于分配共享内存。
  • QSharedMemory::attach() 用于连接到现有的共享内存段。
  • lock() 和 unlock() 用于确保对共享内存的安全访问，避免数据竞争问题。
  • 通过 QBuffer 和 QDataStream 对数据进行序列化和反序列化。

这种方式可以在两个独立的进程之间共享数据，同时使用锁机制确保访问的安全性。

实现原理

QSharedMemory 的实现基于操作系统提供的共享内存机制，其工作原理可以总结为以下几个步骤：

1. 共享内存的创建与管理

QSharedMemory 通过操作系统提供的 API（如 POSIX 的 shmget、shmat，或 Windows 的 CreateFileMapping 和 MapViewOfFile）实现进程间的共享内存。其原理是为不同进程创建一个内存段，使得这些进程可以通过指定的名称或标识符访问同一个内存区域。

  • 创建共享内存：一个进程通过 create() 方法申请一块共享内存。如果这块内存已经存在，则 create() 会返回失败。这可以用来避免多个进程同时创建同一块内存。

  • 连接到共享内存：其他进程通过 attach() 方法连接到已经存在的共享内存。这样，多个进程可以在内存区域中读写数据。

2. 内存映射

操作系统为每个进程提供虚拟地址空间，进程通过 QSharedMemory 将这块共享内存映射到各自的虚拟地址空间中。虽然多个进程有各自的虚拟地址空间，但实际都指向相同的物理内存块。

  • 在 Linux/Unix 系统中，shmget() 和 shmat() 系统调用会将共享内存段映射到进程的地址空间。
  • 在 Windows 系统中，使用 CreateFileMapping() 和 MapViewOfFile() 进行类似的操作。

3. 同步访问

共享内存本身并没有提供任何同步机制，多个进程同时读写共享内存可能会导致数据竞争。因此，QSharedMemory 提供了 lock() 和 unlock() 方法来保护对共享内存的访问。其工作原理是通过底层的操作系统机制（如互斥锁、信号量等）确保只有一个进程在给定时刻可以访问共享内存的特定部分。

  • 在 Linux/Unix 系统中，通常使用 pthread_mutex 或 POSIX 的 sem_open() 实现锁机制。
  • 在 Windows 系统中，可以使用 CreateMutex() 等同步工具。

4. 序列化与数据传输

在共享内存中进行数据传输时，通常会将数据序列化为字节流。例如在前面的示例中，使用 QBuffer 和 QDataStream 将复杂的 Qt 数据类型（如 QString）转化为二进制数据，再存入共享内存。读取进程则会通过反序列化（解码）将二进制数据恢复为原始的数据结构。

  • 数据序列化使得结构化数据（如字符串、对象）可以以连续的字节流形式在共享内存中存储并传递。

5. 进程的分离与共享内存的销毁

每个进程使用完共享内存后，需要调用 detach() 方法将其从虚拟地址空间中移除。如果所有进程都分离了共享内存且没有其他进程在使用它，操作系统会自动释放这块共享内存。

  • 在 Linux/Unix 中，shmdt() 用于分离共享内存，而当最后一个进程分离时，shmctl(IPC_RMID) 会销毁共享内存。
  • 在 Windows 中，UnmapViewOfFile() 和 CloseHandle() 分别用于解除内存映射和释放文件映射对象。

6. 使用场景中的典型问题

  • 数据竞争：如果多个进程同时修改共享内存中的数据，可能会产生数据竞争问题，导致数据不一致或损坏。使用 lock() 和 unlock() 可以避免这种问题。

  • 大小限制：共享内存的大小通常有系统限制，过大的共享内存分配可能失败。需要根据系统的可用资源合理分配。

  • 名称冲突：共享内存通过名称标识，在不同进程中必须使用相同的名称来访问同一块内存。如果名称不一致，进程之间无法共享数据。

总结

QSharedMemory 的实现原理依赖于操作系统底层的共享内存 API，通过虚拟内存映射技术让多个进程可以同时访问同一块物理内存。它结合了锁机制，保证了多进程之间的同步访问。程序员需要管理好内存的分配、同步与销毁，以确保系统的稳定性和安全性。
​

-------------本文结束感谢您的阅读-------------

相关文章