QSharedMemory的attach函数详解

原创 已于 2025-12-05 22:37:01 修改 · 987 阅读 · 25 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #ubuntu #linux #qt

于 2025-12-05 21:50:19 首次发布

概要

关键接口函数详解
函数功能描述参数/返回值示例/说明
构造函数初始化共享内存对象QSharedMemory(QObject *parent = nullptr)
QSharedMemory(const QString &key, QObject *parent = nullptr)		QSharedMemory sharedMemory("MyKey");
setKey()设置共享内存标识键void setKey(const QString &key)sharedMemory.setKey("DataCache");
key()获取当前键值QString key() constqDebug() << sharedMemory.key();
create()创建共享内存段bool create(int size, AccessMode mode = ReadWrite)sharedMemory.create(1024); // 创建1KB内存
attach()附加到已存在的共享内存bool attach(AccessMode mode = ReadWrite)sharedMemory.attach(QSharedMemory::ReadOnly);
detach()从共享内存分离bool detach()sharedMemory.detach(); // 释放资源
lock()锁定共享内存（独占访问）bool lock()成功返回 true，失败需检查错误码
unlock()解锁共享内存bool unlock()操作完成后必须调用
data() / constData()获取内存指针void *data() / const void *constData() constchar *data = static_cast<char*>(sharedMemory.data());
error() / errorString()获取错误信息SharedMemoryError error() const
QString errorString() const		if (error() != QSharedMemory::NoError) qDebug() << errorString();
isAttached()检查是否已附加bool isAttached() constif (sharedMemory.isAttached()) ...
size()获取共享内存大小int size() constqDebug() << sharedMemory.size();

1.QSharedMemory的attach函数详解

功能作用
  • 核心功能：将当前进程关联到由关键字（key）标识的共享内存段，使进程能够访问共享内存数据。
  • 访问模式：默认以ReadWrite（读写）模式附加，也可通过参数指定ReadOnly（只读）模式。
  • 成功条件：若共享内存存在且关联成功，返回true；否则返回false，需通过error()函数排查错误。
参数说明
  • AccessMode mode（可选）：
    • ReadWrite（默认）：允许读写共享内存。
    • ReadOnly：仅允许读取共享内存。
  • 示例：

    cpp

    QSharedMemory sharedMemory;
sharedMemory.setKey("mySharedMemory");
bool success = sharedMemory.attach(QSharedMemory::ReadOnly); // 仅读模式
使用流程
  1. 设置共享内存标识：

    cpp

    sharedMemory.setKey("uniqueKey"); // 必须与创建方使用相同key
  2. 附加共享内存：

    cpp

    if (!sharedMemory.attach()) {
    qDebug() << "Attach failed: " << sharedMemory.errorString();
}
  3. 操作共享内存：
    • 读取数据前需先lock()锁定内存，操作完成后调用unlock()解锁。
    • 写入数据通常在create()创建内存后直接操作，无需重复附加。
  4. 分离与清理：

    cpp

    sharedMemory.detach(); // 解除关联
// 或通过析构函数自动处理
错误处理
  • 常见错误码：
    • QSharedMemory::NotFound（错误码5）：共享内存不存在。
    • QSharedMemory::AlreadyExists（错误码4）：尝试创建已存在的内存段。
    • QSharedMemory::LockError（错误码6）：锁定失败（如未成功附加时调用lock()）。
  • 排查方法：

    cpp

    if (!sharedMemory.attach()) {
    QSharedMemory::SharedMemoryError error = sharedMemory.error();
    if (error == QSharedMemory::NotFound) {
        qDebug() << "共享内存不存在";
    }
}
注意事项
  • 生命周期管理：
    • Unix系统：当所有进程detach()后，系统自动释放共享内存。
    • Windows系统：进程崩溃后系统自动回收内存，但未正确detach()可能导致残留。
  • 并发控制：
    • 使用lock()和unlock()确保多进程/线程访问时的数据一致性。
  • 模式匹配：
    • 写入方需以ReadWrite模式创建内存，读取方必须匹配模式（如只读方需使用ReadOnly模式附加）。
典型场景示例

cpp

// 读取方进程
QSharedMemory reader;
reader.setKey("dataCache");
if (reader.attach(QSharedMemory::ReadOnly)) {
    reader.lock();
    char *data = static_cast<char*>(reader.constData());
    // 读取数据...
    reader.unlock();
    reader.detach();
}

总结：attach()是QSharedMemory实现进程间共享内存访问的核心方法，需结合create()、lock()、unlock()和detach()等函数使用，并严格处理错误与资源释放逻辑。

2.QSharedMemory 接口详细介绍

QSharedMemory 接口详细介绍

核心功能

QSharedMemory 是 Qt 提供的进程间共享内存类，支持多进程通过共享内存段快速传递数据。其核心特性包括：

  • 唯一键标识：通过字符串键（如 "MySharedMemory"）唯一标识共享内存段，不同进程需使用相同键连接。
  • 锁机制：提供 lock() 和 unlock() 确保数据读写时的线程安全。
  • 跨平台支持：自动适配 Windows 和 Unix/Linux 系统的共享内存管理差异。
关键接口函数详解
函数功能描述参数/返回值示例/说明
构造函数初始化共享内存对象QSharedMemory(QObject *parent = nullptr)
QSharedMemory(const QString &key, QObject *parent = nullptr)		QSharedMemory sharedMemory("MyKey");
setKey()设置共享内存标识键void setKey(const QString &key)sharedMemory.setKey("DataCache");
key()获取当前键值QString key() constqDebug() << sharedMemory.key();
create()创建共享内存段bool create(int size, AccessMode mode = ReadWrite)sharedMemory.create(1024); // 创建1KB内存
attach()附加到已存在的共享内存bool attach(AccessMode mode = ReadWrite)sharedMemory.attach(QSharedMemory::ReadOnly);
detach()从共享内存分离bool detach()sharedMemory.detach(); // 释放资源
lock()锁定共享内存（独占访问）bool lock()成功返回 true，失败需检查错误码
unlock()解锁共享内存bool unlock()操作完成后必须调用
data() / constData()获取内存指针void *data() / const void *constData() constchar *data = static_cast<char*>(sharedMemory.data());
error() / errorString()获取错误信息SharedMemoryError error() const
QString errorString() const		if (error() != QSharedMemory::NoError) qDebug() << errorString();
isAttached()检查是否已附加bool isAttached() constif (sharedMemory.isAttached()) ...
size()获取共享内存大小int size() constqDebug() << sharedMemory.size();
访问模式
  • ReadWrite（默认）：允许读写操作。
  • ReadOnly：仅允许读取，适用于只读数据场景。
跨平台差异
  • Windows：系统自动回收共享内存（所有进程分离后）。
  • Unix/Linux：需显式调用 detach() 或析构函数释放内存，否则可能残留。
使用流程
  1. 创建/附加共享内存：

    cpp

    // 创建方
QSharedMemory sharedMemory;
sharedMemory.setKey("GlobalData");
if (!sharedMemory.create(1024)) { /* 错误处理 */ }

// 读取方
if (!sharedMemory.attach()) { /* 错误处理 */ }
  2. 数据操作：

    cpp

    sharedMemory.lock();
char *data = static_cast<char*>(sharedMemory.data());
// 写入数据（如 memcpy(data, "Hello", 5)）
sharedMemory.unlock();
  3. 资源释放：

    cpp

    sharedMemory.detach(); // 或通过析构函数自动处理
错误处理
  • 常见错误码：
    • NotFound（共享内存不存在）
    • AlreadyExists（尝试创建已存在的内存段）
    • LockError（锁定失败）
    • PermissionDenied（无权限访问）
  • 处理示例：

    cpp

    if (!sharedMemory.attach()) {
    qDebug() << "Attach failed: " << sharedMemory.errorString();
}
典型场景示例

写入进程：

cpp

QSharedMemory sharedMemory("DataKey");
sharedMemory.create(1024);
sharedMemory.lock();
memcpy(sharedMemory.data(), "Hello", 5);
sharedMemory.unlock();

读取进程：

cpp

QSharedMemory sharedMemory("DataKey");
sharedMemory.attach();
sharedMemory.lock();
const char *data = static_cast<const char*>(sharedMemory.constData());
qDebug() << "Read data: " << QString(data);
sharedMemory.unlock();
sharedMemory.detach();
注意事项
  • 键值一致性：所有进程必须使用相同的键值。
  • 锁机制：操作前必须调用 lock()，完成后调用 unlock()。
  • 资源管理：避免重复创建/附加，及时 detach() 防止内存泄漏。
  • 数据大小：创建时需预留足够空间，避免溢出。

总结：QSharedMemory 通过简洁的接口实现了高效的进程间数据共享，需结合锁机制和错误处理确保安全使用，同时注意跨平台行为差异。

3.Qt共享内存锁定错误解决方案

这个错误信息表明在Qt框架中，尝试对一个已经处于锁定状态的QSharedMemory对象再次调用lock()方法时触发了错误。以下是详细分析和解决方案：

错误原因分析

  1. 重复锁定同一对象：
    • 同一个进程/线程多次调用lock()而未释放锁（未调用unlock()）。
    • 例如：在循环中或递归调用中重复锁定，或逻辑错误导致锁未被释放。
  2. 锁未正确释放：
    • 异常退出（如崩溃、未捕获的异常）导致unlock()未执行。
    • 锁的生命周期管理不当（如局部对象提前销毁）。
  3. 多进程/线程竞争：
    • 其他进程/线程已锁定共享内存，当前进程等待超时或错误处理。

解决方案

1. 确保锁的配对使用
  • 成对调用：每次lock()必须对应一次unlock()，即使在异常路径中也要释放锁。
  • 示例代码修正：

    cpp

    QSharedMemory sharedMem;
// ... 初始化共享内存 ...

if (sharedMem.lock()) {
    // 操作共享内存
    sharedMem.unlock(); // 必须显式解锁
} else {
    // 处理锁定失败（如其他进程持有锁）
}
2. 使用RAII模式管理锁
  • 通过封装类自动管理锁的生命周期，避免遗漏解锁：

    cpp

    class SharedMemoryLocker {
public:
    SharedMemoryLocker(QSharedMemory &mem) : m_mem(mem) {
        m_mem.lock();
    }
    ~SharedMemoryLocker() {
        if (m_mem.isAttached()) {
            m_mem.unlock();
        }
    }
private:
    QSharedMemory &m_mem;
};

// 使用方式
QSharedMemory sharedMem;
SharedMemoryLocker locker(sharedMem); // 自动上锁
// 操作共享内存（无需手动解锁）

3. 检查多线程/进程同步
  • 线程安全：若多线程访问同一QSharedMemory，需额外使用QMutex或QReadWriteLock协调。
  • 进程间通信：确认其他进程是否已释放锁（如通过信号量、管道等机制同步）。
4. 调试与日志
  • 添加日志：在lock()和unlock()前后记录日志，跟踪锁状态。
  • 异常捕获：使用try-catch块确保异常时解锁：

    cpp

    try {
    if (sharedMem.lock()) {
        // 操作共享内存
    }
} catch (...) {
    sharedMem.unlock(); // 确保解锁
    throw; // 重新抛出异常
}

5. 检查共享内存状态
  • 使用QSharedMemory::isAttached()检查是否已附着到共享内存。
  • 使用QSharedMemory::key()确认共享内存的唯一标识，避免冲突。

常见场景示例

  • 场景1：在循环中重复锁定

    cpp

    // 错误：循环内多次锁定，未解锁
for (int i = 0; i < 10; ++i) {
    sharedMem.lock(); // 第二次迭代时触发错误
    // ...
}

    修正：将锁移到循环外，或确保每次循环解锁。

  • 场景2：多线程未同步

    cpp

    // 线程A
sharedMem.lock();
// 线程B同时尝试锁定

    修正：使用全局互斥锁协调线程间访问。

总结

该错误的核心是锁管理不当。通过确保lock()/unlock()成对调用、使用RAII模式、添加异常处理和同步机制，可有效解决问题。若涉及多进程，需结合进程间通信（如信号量）协调锁状态。建议通过日志和调试工具（如Qt Creator的调试器）跟踪锁的生命周期，定位具体代码位置。

4.Qt共享内存锁机制解析与安全实践

在提供的代码片段中：

cpp

if (sharedMem.isAttached()) {
    sharedMem.detach();
}

不会执行sharedMem.lock()，也不会触发QSharedMemory::lock: already locked错误。以下是详细分析：

1. 代码逻辑解析

  • isAttached()：仅检查当前对象是否已附加到共享内存段（返回true表示已附加）。
  • detach()：执行分离操作，释放当前进程与共享内存段的连接，并自动释放锁（如果之前已锁定）。

2. 锁状态管理

  • detach()的隐含行为：根据Qt文档，调用detach()会自动释放锁（如果存在）。即：

    cpp

    sharedMem.lock();   // 手动加锁
sharedMem.detach(); // 自动解锁并分离
    因此，在detach()后，锁已被释放，不会残留锁定状态。

3. 错误触发条件

QSharedMemory::lock: already locked错误仅在显式重复调用lock()时触发，例如：

cpp

sharedMem.lock(); // 第一次锁定（成功）
sharedMem.lock(); // 第二次锁定（触发错误）

而你的代码中没有lock()调用，因此不会触发此错误。

4. 安全使用建议

尽管上述代码安全，但更推荐使用RAII模式管理锁和共享内存生命周期，避免手动管理错误：

cpp

class SharedMemoryGuard {
public:
    SharedMemoryGuard(QSharedMemory &mem) : m_mem(mem) {
        m_mem.lock(); // 自动加锁
    }
    ~SharedMemoryGuard() {
        if (m_mem.isAttached()) {
            m_mem.unlock(); // 自动解锁
            m_mem.detach(); // 可选：分离内存
        }
    }
private:
    QSharedMemory &m_mem;
};

// 使用方式
QSharedMemory sharedMem;
SharedMemoryGuard guard(sharedMem); // 自动加锁
// 操作共享内存（无需手动解锁）
// 离开作用域时自动解锁并分离

5. 关键结论

  • 你的代码不会触发already locked错误，因为：
    • 没有重复调用lock()。
    • detach()会隐含释放锁。
  • 潜在风险：如果其他代码路径存在重复lock()调用，仍可能触发错误。建议全局检查锁的生命周期管理。

通过RAII模式可彻底避免锁管理错误，推荐在实际项目中采用。

5.qt 线程等待一秒钟后执行

在Qt中实现线程等待一秒钟后执行任务，需根据场景选择合适的方法。以下是几种安全且高效的方式，避免阻塞主线程导致界面冻结：

1. 主线程场景：使用QTimer异步延时

推荐方案：通过事件循环触发延时任务，不阻塞GUI。

cpp

// 示例：1秒后执行槽函数
QTimer::singleShot(1000, this, [this]() {
    qDebug() << "1秒后执行的任务";
    // 此处可调用业务逻辑或更新UI
});
  • 优点：非阻塞，保持界面响应。
  • 适用：主线程中延时执行UI操作或业务逻辑。

2. 工作线程场景：QThread + QTimer

方案：在工作线程中启动定时器，通过信号槽触发任务。

cpp

class Worker : public QObject {
    Q_OBJECT
public slots:
    void doWork() {
        qDebug() << "工作线程开始";
        QTimer::singleShot(1000, this, &Worker::executeTask);
    }

private slots:
    void executeTask() {
        qDebug() << "1秒后执行的任务";
        emit finished();
    }

signals:
    void finished();
};

// 启动工作线程
QThread *thread = new QThread();
Worker *worker = new Worker();
worker->moveToThread(thread);
connect(thread, &QThread::started, worker, &Worker::doWork);
connect(worker, &Worker::finished, thread, &QThread::quit);
thread->start();
  • 优点：工作线程独立处理，不干扰主线程。
  • 注意：确保工作线程的生命周期管理（如thread->quit()后需deleteLater）。

3. 精确延时：QEventLoop + QTimer

方案：在局部作用域内启动事件循环，实现阻塞式等待（需谨慎使用）。

cpp

void waitAndExecute() {
    qDebug() << "等待1秒...";
    QEventLoop loop;
    QTimer::singleShot(1000, &loop, &QEventLoop::quit);
    loop.exec(); // 阻塞当前线程，直到loop退出
    qDebug() << "1秒后执行的任务";
}
  • 适用：非GUI线程或后台线程中的精确延时。
  • 警告：禁止在主线程中使用！会导致界面冻结。

4. 线程休眠（慎用）

方案：在非GUI线程中使用QThread::msleep。

cpp

void WorkerThread::run() override {
    qDebug() << "线程开始";
    QThread::msleep(1000); // 阻塞1秒
    emit taskDone();
}
  • 适用：纯CPU工作线程（无GUI操作）。
  • 风险：过度使用会浪费CPU资源，且需手动管理线程同步。

关键注意事项

  1. 主线程禁止阻塞：
    • 避免使用msleep、sleep或QEventLoop::exec()，否则界面会冻结。
    • 优先使用QTimer::singleShot或信号槽异步机制。
  2. 线程安全：
    • 跨线程操作需通过信号槽或QMetaObject::invokeMethod。
    • 共享数据需用QMutex、QReadWriteLock或QMutexLocker保护。
  3. 资源管理：
    • 使用QThread时，确保在退出时调用quit()和wait()，避免内存泄漏。
    • 使用QObject::deleteLater()管理跨线程对象的生命周期。

选择策略

  • 主线程任务 → QTimer::singleShot
  • 后台任务 → QThread + QTimer 或 QtConcurrent
  • 精确控制 → QEventLoop（仅限非GUI线程）
  • 简单延时 → QThread::msleep（仅限工作线程）

通过以上方法，可安全实现Qt中的延时任务，同时保持应用流畅响应。

QT之QSharedMemory 详解 进程间通信
SmallBottle-CGWLMX的博客
09-13 9676
QSharedMemory的几个重要接口： setKey（），这是标记共享内存的一个标识符， 在整个操作系统的共享内存中，用这个key去标识它，唯一标识。 create（），创建共享内存，向os申请内存空间， 如果不创建，调用attach（）会失败， 在create（）的时候，需要制定共享内存的大小，即字节数， 跟windows的CreateFileMapping（）一样，都是需要在create...
QSharedMemory使用详解
最新发布
weixin_39291964的博客
08-08 437
摘要：QSharedMemory是Qt中实现高效进程间通信(IPC)的核心类，通过共享内存段允许多个进程直接访问同一物理内存。文章详细介绍了其工作原理、基础操作流程（创建、附加、读写、清理）和进阶技巧（同步机制增强、数据结构设计）。特别强调了平台差异（Windows自动回收内存，Unix需手动清理）和常见问题解决方案（内存残留处理、多进程竞争初始化）。文章还对比了不同IPC方式的优缺点，并提供了完整的双进程通信示例，适用于图像、视频等大数据传输场景。
Qt 学习之路 ：进程间通信
weixin_30617737的博客
09-15 218
上一章我们了解了有关进程的基本知识。我们将进程理解为相互独立的正在运行的程序。由于二者是相互独立的，就存在交互的可能性，也就是我们所说的进程间通信（Inter-Process Communication，IPC）。不过也正因此，我们的一些简单的交互方式，比如普通的信号槽机制等，并不适用于进程间的相互通信。我们说过，进程是操作系统的基本调度单元，因此，进程间交互不可避免与操作系统的实现息息...
Qt进程通信之共享内存（QSharedMemory）
weixin_43246170的博客
02-27 4166
比如单机上只有一个实例，该实例需要在启动的时候加载一大块资源到内存，那么，如果基于共享内存，将资源加载到共享内存，那么，下次启动的时候，只要version或者crc没变，就可以直接挂载使用，无需再次读入。比如程序启动需要加载cpu型号、内存信息、系统属性、配置文件数据等等时，软件第一次启动时先将数据加载到共享内存，后面启动时只需要从共享内存读取数据，提升程序的启动速度。两个进程同时挂载一片共享内存，进程A写、进程B读，就达到了通信效果，这种方案的好处是，读写都是基于内存操作，效率非常之高。
QSharedMemory介绍
路过的熊的博客
12-16 1228
QSharedMemory介绍
Qt之共享内存类QSharedMemory的使用及实现原理(全)
红军不怕远征难，万水千山只等闲
03-28 1987
跨平台支持：对不同操作系统（如 Windows、Linux 等）的底层共享内存机制进行封装，屏蔽了各系统间的差异，为开发者提供统一的接口，方便在不同平台上实现进程间共享内存通信。简化操作：提供了创建、附加、分离、删除共享内存等操作的简单方法，降低了使用共享内存的复杂度，开发者无需深入了解底层系统调用细节。数据共享：允许不同进程或线程访问同一块物理内存区域，实现高效的数据共享，避免了数据在不同进程间的多次拷贝，提高了数据传输效率。从使用的角度来讲，尤其是在线程或进程间数据通信来讲还是非常方便的；
Qt 学习记录 ： 共享内存 QSharedMemory
Beyond欣
01-09 2676
  最近遇到一个bug，程序在windos下和linux下效果不同。找了下是因为OS本身设计就不一样。 Windos的共享内存在所有引用的进程的关闭时（包括闪退）自动清空。 Linux的共享内存在所有引用的进程的关闭时（不包括闪退）自动清空。 原文：https://doc.qt.io/qt-5.15/qsharedmemory.html#details   既然遇到了问题，直接记录下QSharedMemory的使用方法，方便自己查找。 ...
D:\QtProject\FaceLogin\main.cpp:85: error: C2660: “QSharedMemory::setNativeKey”: 函数不接受 2 个参数 D:\QtProject\FaceLogin\main.cpp(85): error C2660: “QSharedMemory::setNativeKey”: 函数不接受 2 个参数 D:\Qt\5.15.2\msvc2019_64\include\QtCore\qsharedmemory.h(103): note: 参见“QSharedMemory::setNativeKey”的声明
06-24
我们遇到了一个编译错误，提示`QSharedMemory::setNativeKey`函数不接受2个参数。在Qt的文档中，`setNativeKey`函数有两个重载版本：1.`voidsetNativeKey(constQString&key)`2.`voidsetNativeKey(constchar*key)`...
qt linux 共享内存,qt 共享内存(QSharedMemory)
weixin_39623671的博客
04-30 926
——————————————————写入部分——————————————————(本次程序基于控制台程序)首先 使用共享内存得召唤一下：#include 然后 声明QSharedMemory类。并且命名为smemQSharedMemory smem;由于共享内存没有访问密钥，则不能找到共享的内存。我们给他设置一下访问密钥QString key,sharedstring;设置访问密钥qDebug()...
QT共享内存程序源码实现详解
- `QSharedMemory构造函数`：可以创建一个新的共享内存对象或者与一个已存在的共享内存对象关联。 - `attach()`：将当前进程附加到共享内存，使其能够读写共享内存中的数据。 - `detach()`：断开当前进程与共享内存...
Qt学习—qt共享内存的使用
热门推荐
GDUTLYP的专栏
01-06 2万+
Qt提供了QSharedMemory类来访问共享内存，实现共享内存的操作。 一、QSharedMemory类常用的操作 1、QSharedMemory类对象的创建 利用QSharedMemory类创建实例对象时，必须为该共享内存指定关键字(即为该共享内存起一个名字)。只有当共享内存被设置了关键字之后，才可以执行创建create()、关联attach()等操作。为共享内存指定关键字有两种方
【Qt】QSharedMemory类详解
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师、鸿蒙讲师---欢迎大家一起交流(私信添加博主微信)
01-04 1万+
00. 目录 文章目录00. 目录01. 概述02. 公有类型03. 成员方法04. 程序示例一05. 程序示例二06. 源码下载07. 附录 01. 概述 QSharedMemory提供了多个线程和进程对共享内存段的访问。它还提供了一种方法，让单个线程或进程锁定内存以进行独占访问。 当使用这个共享内存类时，请注意以下平台差异: Windows：QSharedMemory 不“拥有”共享内存段。当所有具有连接到特定共享内存段的 QSharedMemory 实例的线程或进程已销毁其 QSharedMemor
QSharedMemory类
FinixLei的专栏 (https://github.com/FinixLei)
06-04 3506
翻译。原文：http://doc.qt.io/qt-5.6/qsharedmemory.html
QSharedMemory
me_badman的博客
02-09 7621
来源：https://www.devbean.net/2013/11/qt-study-road-2-ipc/ Qt 提供了四种进程间通信的方式： 1.使用共享内存（shared memory）交互：这是 Qt 提供的一种各个平台均有支持的进程间交互的方式。 2.TCP/IP：其基本思想就是将同一机器上面的两个进程一个当做服务器，一个当做客户端，二者通过网络协议进行交互。除了两个进程是在同一台
Linux下使用QSharedMemory异常退出时共享内存未释放解决办法
xinluo7的博客
06-26 4129
首先看一下QSharedMemory在不同平台下的差异问题 详细描述 QSharedMemory 类提供了对一段共享内存的访问。（译注：“一段共享内存”在后续译文中也译为“共享内存段”） QSharedMemory 提供了被多线程和多进程共享的一段内存的访问。它也提供了方法，为单线程或单进程锁定内存以实现互斥访问。 当使用这个类的时候，要知道以下不同平台的差异： Windows： QSharedMemory并不“拥有”这段共享内存。当所有“拥有一个QSharedMemory的实例从而附着于某一段共享
67.QT-QSharedMemory
抵抗时间扭曲，坚持做一件有意义的事
08-09 1404
1.QSharedMemory介绍 QSharedMemory提供了多个线程和进程对共享内存段的访问。它还提供了一种方法，让单个线程或进程锁定内存以进行独占访问。 当使用这个类时，请注意以下平台差异: Windows: QSharedMemory不“拥有”共享内存段。当有QSharedMemory实例附加到特定共享内存段的所有线程或进程销毁了它们的QSharedMemory实例或者退出了，Wi...
linux qt程序运行示例,Qt程序只运行一个实例
weixin_39827589的博客
05-02 784
在我的这篇文章中使Qt程序只运行一个实例，通过QSharedMemory来实现进程间通讯，使用这种方式来是Qt程序只运行一个实例。有一天测试部的MM告诉我，她在测试的时候，程序crash掉了，再次运行程序，程序不能继续运行。程序不能运行，显然是共享内存没有释放引起的，但是程序crash后为什么共享内存不能释放呢？于是打开Qt助手看到QSharedMemory是这样解释的：Unix: QShared...
Linux单实例进程
dsg333的专栏
07-30 1006
#include stdio.h> #include stdlib.h> #include unistd.h> #include fcntl.h> #include syslog.h> #include string.h> #include errno.h> #include sys/stat.h> #define LOCKFILE "/var/run/mydaemon.pid
qsharedmemory 封装函数
06-06
QSharedMemory是Qt中的一个类，用于在多个进程之间共享内存。下面是一个简单的QSharedMemory封装函数： ```cpp #include <QSharedMemory> #include <QString> #include <QBuffer> bool writeDataToSharedMemory(const QString& key, QByteArray& data) { QSharedMemory sharedMemory(key); if (sharedMemory.isAttached()) { sharedMemory.detach(); } if (!sharedMemory.create(data.size())) { return false; } sharedMemory.lock(); char* to = static_cast<char*>(sharedMemory.data()); const char* from = data.constData(); memcpy(to, from, qMin(sharedMemory.size(), static_cast<quint64>(data.size()))); sharedMemory.unlock(); return true; } bool readDataFromSharedMemory(const QString& key, QByteArray& data) { QSharedMemory sharedMemory(key); if (!sharedMemory.attach()) { return false; } sharedMemory.lock(); QBuffer buffer; buffer.setData(static_cast<const char*>(sharedMemory.constData()), sharedMemory.size()); buffer.open(QBuffer::ReadOnly); data = buffer.readAll(); sharedMemory.unlock(); sharedMemory.detach(); return true; } ``` 这个函数包含两个函数，一个用于将数据写入共享内存，另一个用于从共享内存中读取数据。在这个函数中，我们使用QBuffer类将共享内存中的数据读入QByteArray中，然后将其返回。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值