buntu qt c++ 避免程序重复启动_c++防重复运行-优快云博客

本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/146401614

1.概要

2.内容

在Ubuntu下使用Qt C++避免程序重复启动，可以通过以下两种方法实现：

方法一：使用 `QSharedMemory`（跨平台，需处理残留问题）

原理

通过共享内存段检测程序是否已运行。若创建失败，说明已有实例存在。

实现步骤

创建共享内存：使用唯一键名（如应用名称）。
处理残留问题：检查存储的PID对应的进程是否存活。
清理资源：程序退出时释放共享内存。

示例代码

#include <QCoreApplication>
#include <QSharedMemory>
#include <QProcess>

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

    QSharedMemory sharedMemory;
    const QString key = "MyAppUniqueKey";
    sharedMemory.setKey(key);

    // 尝试创建共享内存（大小为存储PID所需）
    if (!sharedMemory.create(sizeof(qint64))) {
        // 已有实例运行，检查PID有效性
        if (sharedMemory.attach()) {
            sharedMemory.lock();
            qint64 storedPid = *reinterpret_cast<qint64*>(sharedMemory.data());
            sharedMemory.unlock();

            // 检查进程是否存在
            QProcess process;
            process.start("kill", QStringList() << "-0" << QString::number(storedPid));
            if (process.waitForFinished() && process.exitCode() == 0) {
                qDebug() << "程序已在运行，PID:" << storedPid;
                return 1;
            } else {
                // 旧进程已退出，覆盖共享内存
                sharedMemory.detach();
                if (!sharedMemory.create(sizeof(qint64))) {
                    qDebug() << "共享内存创建失败";
                    return 1;
                }
            }
        }
    }

    // 存储当前进程PID
    sharedMemory.lock();
    *reinterpret_cast<qint64*>(sharedMemory.data()) = QCoreApplication::applicationPid();
    sharedMemory.unlock();

    // 退出时清理共享内存
    QObject::connect(&a, &QCoreApplication::aboutToQuit, [&]() {
        sharedMemory.detach();
    });

    return a.exec();
}

方法二：使用 `QLocalServer`（Qt5+，自动清理）

原理

通过本地套接字服务器检测实例。若连接成功，说明已有实例运行。

实现步骤

尝试连接服务器：使用唯一服务器名。
创建服务器：若连接失败，则创建新服务器。
自动清理：程序退出后，Qt自动移除服务器文件。

示例代码

#include <QCoreApplication>
#include <QLocalServer>
#include <QLocalSocket>

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

    QLocalServer server;
    const QString serverName = "MyAppLocalServer";
    QLocalSocket socket;

    // 尝试连接已有服务器
    socket.connectToServer(serverName);
    if (socket.waitForConnected(500)) { // 超时500ms
        qDebug() << "程序已在运行";
        return 1;
    }

    // 移除旧服务器文件（避免残留）
    QLocalServer::removeServer(serverName);

    // 创建新服务器
    if (!server.listen(serverName)) {
        qDebug() << "服务器创建失败";
        return 1;
    }

    // 其他初始化代码...

    return a.exec();
}

方法对比

方法	优点	缺点
`QSharedMemory`	跨平台，资源占用低	需处理进程残留问题
`QLocalServer`	自动清理，代码简洁	仅Qt5+，依赖文件系统权限

注意事项

唯一标识：确保键名/服务器名全局唯一（如使用应用名称+版本号）。
权限问题：避免使用系统保留名称，确保程序有权限操作共享内存或文件。
异常退出：QLocalServer 在程序崩溃后可能残留文件，可通过 removeServer 清理。

根据需求选择合适的方法，若需跨平台且处理残留，推荐 QSharedMemory；若仅Ubuntu且Qt5+，推荐 QLocalServer。

3.关联链接

4.关联知识

1.QLocalSocketqt 6.7 还支持吗

在 Qt 6.7 中，QLocalSocket 和 QLocalServer 的支持情况如下：

1. 官方状态：

Qt 6 开始，QLocalSocket 被标记为 过时（Deprecated），且在 Windows 平台已移除支持。
Unix-like 系统（如 Linux/macOS）：仍保留基本功能，但官方不再积极维护，推荐使用替代方案。

2. 原因：

Qt 团队认为本地套接字（Local Sockets）的跨平台维护成本较高，且存在平台差异（如 Windows 命名管道 vs. Unix 域套接字）。
推荐使用更现代、跨平台的 IPC 机制（如 QSharedMemory 或第三方库）。

3. 替代方案：

跨平台 IPC：
- QSharedMemory：适合共享简单数据。
- 使用第三方库（如 Boost.Interprocess、ZeroMQ）。
平台特定 API：
- Windows：直接使用命名管道（Named Pipes）API。
- Unix：使用域套接字（Domain Sockets）或 QProcess + 标准输入输出。

4. 兼容性建议：

如果项目依赖 QLocalSocket，建议：
- 迁移到 Qt 5（长期支持版本仍可用）。
- 重构代码，使用替代 IPC 方案。
- 条件编译：在 Unix 平台保留 QLocalSocket，Windows 平台改用其他方法。

示例：跨平台兼容代码

#ifdef Q_OS_WIN
    // Windows 使用命名管道或其他替代方案
#else
    // Unix 使用 QLocalSocket
    QLocalSocket socket;
    socket.connectToServer("MyAppSocket");
#endif

总结：

Qt 6.7 中 QLocalSocket 在 Windows 已不可用，Unix 平台虽保留但官方不推荐。建议评估项目需求，选择更稳定的 IPC 方案以确保跨平台兼容性。

2.QSharedMemory

QSharedMemory 是 Qt 框架中用于实现进程间通信（IPC）的一个类，它允许不同的进程共享一块内存区域，从而实现高效的数据交换。以下是关于 QSharedMemory 的详细介绍：

一、基本概念

共享内存：共享内存是一种内存映射文件，允许两个或多个进程共享同一块内存空间。通过共享内存，进程可以直接读写同一块数据，而无需通过文件或网络进行传输，从而提高了数据交换的效率。
唯一键（Key）：每块共享内存都有一个唯一的关键字（Key）用于标识。进程通过指定相同的键来访问同一块共享内存。

二、主要功能

创建和连接共享内存
- 创建共享内存：使用 create() 方法可以创建一个指定大小的共享内存段。如果共享内存已经存在，并且当前进程没有权限访问，则创建操作会失败。
- 连接共享内存：使用 attach() 方法可以连接到一个已经存在的共享内存段。如果连接成功，进程就可以访问该共享内存中的数据。
读写数据
- 写入数据：进程可以通过共享内存的指针将数据写入到共享内存中。写入操作通常是以字节为单位进行的。
- 读取数据：进程可以通过共享内存的指针从共享内存中读取数据。读取操作同样是以字节为单位进行的。
同步控制
- 锁定和解锁：由于多个进程可以同时访问共享内存，因此需要使用同步机制来防止数据竞争。QSharedMemory 提供了 lock() 和 unlock() 方法来实现简单的锁定和解锁操作。
- 结合其他同步机制：虽然 QSharedMemory 本身并不提供复杂的同步机制，但可以结合 Qt 中的其他同步类（如 QMutex、QSemaphore）来实现更复杂的同步控制。

三、使用示例

以下是一个简单的示例，演示如何使用 QSharedMemory 在两个进程之间共享数据。

进程 A（写入数据）：

#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.create(1024)) {
        qDebug() << "Unable to create shared memory:" << sharedMemory.errorString();
        return -1;
    }

    // 写入数据到共享内存
    QByteArray data;
    QBuffer buffer(&data);
    buffer.open(QBuffer::WriteOnly);
    QDataStream out(&buffer);
    out << QString("Hello from process A");
    buffer.close();

    sharedMemory.lock();
    char *to = (char *)sharedMemory.data();
    const char *from = data.data();
    memcpy(to, from, qMin(sharedMemory.size(), data.size()));
    sharedMemory.unlock();

    qDebug() << "Process A wrote data to shared memory.";
    return a.exec();
}

进程 B（读取数据）：

#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:" << sharedMemory.errorString();
        return -1;
    }

    sharedMemory.lock();
    QBuffer buffer;
    QDataStream in(&buffer);
    QByteArray data((char *)sharedMemory.constData(), sharedMemory.size());
    buffer.setData(data);
    buffer.open(QBuffer::ReadOnly);
    QString message;
    in >> message;
    sharedMemory.unlock();

    qDebug() << "Process B read data from shared memory:" << message;
    return a.exec();
}

四、注意事项

大小限制：共享内存的大小是有限制的，具体大小取决于操作系统。在创建共享内存时，需要合理估计所需的大小。
同步问题：由于多个进程可以同时访问共享内存，因此必须使用同步机制来防止数据竞争。虽然 QSharedMemory 提供了简单的锁定和解锁操作，但在复杂的应用场景中，可能需要结合其他同步类来实现更可靠的同步控制。
错误处理：在使用 QSharedMemory 时，应随时检查返回值并处理可能的错误。可以通过 errorString() 方法获取详细的错误信息。

五、总结

QSharedMemory 是 Qt 框架中用于实现进程间通信的一种高效方式。通过共享内存，不同的进程可以共享数据，从而提高数据交换的效率。在使用 QSharedMemory 时，需要注意同步问题和错误处理，以确保数据的正确性和程序的稳定性。

2.QSharedMemory常用接口

QSharedMemory 是 Qt 框架中用于在不同进程间共享内存的一个类。它提供了一组接口，允许开发者创建、连接、写入、读取以及管理共享内存段。以下是 QSharedMemory 的一些常用接口及其功能介绍：

1. 构造函数

QSharedMemory(const QString &key, QObject *parent = nullptr)：
- 功能：使用指定的键（key）创建一个 QSharedMemory 对象。
- 参数：
  - key：共享内存的唯一标识符。
  - parent：对象的父对象，通常设置为 nullptr。
QSharedMemory(QObject *parent = nullptr)：
- 功能：创建一个 QSharedMemory 对象，但不指定键。键需要在之后通过 setKey() 方法设置。
- 参数：
  - parent：对象的父对象，通常设置为 nullptr。

2. 设置和获取键

setKey(const QString &key)：
- 功能：为共享内存段设置唯一的键。
- 参数：
  - key：共享内存的唯一标识符。
key() const：
- 功能：获取共享内存段的键。
- 返回值：返回共享内存的键（QString 类型）。

3. 创建和连接共享内存

create(int size, QSharedMemory::AccessMode mode = ReadWrite)：
- 功能：创建一个指定大小的共享内存段。如果共享内存已经存在，并且当前进程没有权限访问，则创建操作会失败。
- 参数：
  - size：共享内存的大小（以字节为单位）。
  - mode：访问模式，可以是 ReadOnly 或 ReadWrite，默认为 ReadWrite。
attach(QSharedMemory::AccessMode mode = ReadWrite)：
- 功能：连接到一个已经存在的共享内存段。如果连接成功，进程就可以访问该共享内存中的数据。
- 参数：
  - mode：访问模式，可以是 ReadOnly 或 ReadWrite，默认为 ReadWrite。
detach()：
- 功能：将共享内存段与当前进程分离。分离后，进程将无法再访问该共享内存中的数据。
isAttached() const：
- 功能：检查当前进程是否已经连接到共享内存段。
- 返回值：如果已连接，返回 true；否则返回 false。

4. 锁定和解锁共享内存

lock()：
- 功能：锁定共享内存段，以防止其他进程同时访问。
- 返回值：如果锁定成功，返回 true；否则返回 false。
unlock()：
- 功能：解锁共享内存段，以允许其他进程访问。
- 返回值：如果解锁成功，返回 true；否则返回 false。

5. 访问共享内存数据

data() const：
- 功能：获取共享内存段的指针，用于读写数据。
- 返回值：返回指向共享内存数据的指针（void* 类型）。
constData() const：
- 功能：类似于 data()，但返回的是常量指针，用于只读访问共享内存数据。
- 返回值：返回指向共享内存数据的常量指针（const void* 类型）。
size() const：
- 功能：获取共享内存段的大小（以字节为单位）。
- 返回值：返回共享内存的大小（int 类型）。

6. 错误处理

error() const：
- 功能：获取共享内存操作中的错误代码。
- 返回值：返回错误代码（QSharedMemory::SharedMemoryError 类型）。
errorString() const：
- 功能：获取共享内存操作中的错误信息的字符串描述。
- 返回值：返回错误信息的字符串描述（QString 类型）。

示例代码

以下是一个简单的示例，展示如何使用 QSharedMemory 在两个进程之间共享数据：

#include <QCoreApplication>
#include <QSharedMemory>
#include <QBuffer>
#include <QDataStream>
#include <QDebug>

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

    QSharedMemory sharedMemory("MySharedMemoryKey");

    // 进程 A（写入数据）
    if (argc == 1) {
        if (!sharedMemory.create(1024)) {
            qDebug() << "Unable to create shared memory:" << sharedMemory.errorString();
            return -1;
        }

        // 写入数据到共享内存
        QByteArray data;
        QBuffer buffer(&data);
        buffer.open(QBuffer::WriteOnly);
        QDataStream out(&buffer);
        out << QString("Hello from process A");
        buffer.close();

        sharedMemory.lock();
        char *to = static_cast<char *>(sharedMemory.data());
        const char *from = data.data();
        memcpy(to, from, qMin(sharedMemory.size(), data.size()));
        sharedMemory.unlock();

        qDebug() << "Process A wrote data to shared memory.";
    }

    // 进程 B（读取数据）
    else {
        if (!sharedMemory.attach()) {
            qDebug() << "Unable to attach to shared memory:" << sharedMemory.errorString();
            return -1;
        }

        sharedMemory.lock();
        QBuffer buffer;
        QDataStream in(&buffer);
        QByteArray data(static_cast<const char *>(sharedMemory.constData()), sharedMemory.size());
        buffer.setData(data);
        buffer.open(QBuffer::ReadOnly);
        QString message;
        in >> message;
        sharedMemory.unlock();

        qDebug() << "Process B read data from shared memory:" << message;
    }

    return a.exec();
}

在这个示例中，进程 A 创建共享内存并写入数据，进程 B 连接到共享内存并读取数据。通过共享内存，两个进程之间实现了高效的数据交换。