Qt跨进程函数触发：寻求跨Windows/Linux的简易IPC方案

看来你已经在Qt进程间通信上有了一些实践，现在想要实现更优雅的跨进程函数触发需求——比如App1点击按钮就触发App2打印"HelloWorld"。针对你提到的跨Windows/Linux兼容、追求简易性的要求，我给你几个基于Qt原生API的方案，都比轮询QSharedMemory的方式更高效优雅：

1. Qt Remote Objects（QtRO）：最贴合Qt信号槽习惯的方案 #

这是Qt官方专门为跨进程/跨设备信号槽通信设计的模块，完美匹配你想要的“触发函数”场景，跨Windows和Linux毫无压力，而且代码逻辑和你平时写Qt本地信号槽几乎一致，学习成本极低。

简单实现步骤： #

首先，你需要在项目文件中添加模块依赖：

QT += remoteobjects

然后定义一个接口文件（比如SimpleInterface.rep），用来声明需要跨进程调用的信号/槽：

// SimpleInterface.rep
class SimpleInterface
{
    SIGNAL(triggerHello())
};

qmake会自动根据这个文件生成对应的Replica和Implementation类。

App2（服务端，提供被触发的函数）：

#include <QApplication>
#include <QRemoteObjectHost>
#include "SimpleInterfaceReplica.h"

// 实现接口的类，处理triggerHello信号
class SimpleInterfaceImpl : public QObject
{
    Q_OBJECT
public slots:
    void handleTrigger() {
        qDebug() << "HelloWorld";
    }
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    SimpleInterfaceImpl impl;
    // 创建服务端，发布接口到本地地址
    QRemoteObjectHost host(QUrl("local:AppTriggerService"));
    host.enableRemoting(&impl);

    // 绑定信号：当客户端触发triggerHello时，执行我们的打印函数
    QObject::connect(host.remoteObject<SimpleInterfaceReplica>(), &SimpleInterfaceReplica::triggerHello,
                     &impl, &SimpleInterfaceImpl::handleTrigger);

    return app.exec();
}
#include "main.moc"

App1（客户端，触发函数）：

#include <QApplication>
#include <QPushButton>
#include <QRemoteObjectNode>
#include "SimpleInterfaceReplica.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QPushButton btn("触发App2打印");
    btn.show();

    // 连接到服务端
    QRemoteObjectNode clientNode;
    clientNode.connectToNode(QUrl("local:AppTriggerService"));
    // 获取接口的Replica
    auto replica = clientNode.acquire<SimpleInterfaceReplica>();

    // 按钮点击时触发跨进程信号
    QObject::connect(&btn, &QPushButton::clicked, [replica](){
        if (replica->isReplicaValid()) {
            emit replica->triggerHello();
        } else {
            qDebug() << "未连接到App2";
        }
    });

    return app.exec();
}

这个方案完全用你熟悉的信号槽逻辑，没有额外的通信协议需要处理，非常优雅。

2. QLocalSocket/QLocalServer：轻量本地IPC首选 #

如果不想引入QtRO模块，QLocalSocket是个非常轻量的选择——它在Windows上用命名管道，Linux上用Unix域套接字，跨平台兼容，代码量极小，适合简单的触发场景。

App2（服务端）：

#include <QApplication>
#include <QLocalServer>
#include <QLocalSocket>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QLocalServer server;
    // 启动服务，命名为唯一标识
    if (!server.listen("App2TriggerServer")) {
        qDebug() << "服务启动失败：" << server.errorString();
        return 1;
    }

    // 处理新连接
    QObject::connect(&server, &QLocalServer::newConnection, [&](){
        QLocalSocket* socket = server.nextPendingConnection();
        // 读取客户端发送的指令
        QObject::connect(socket, &QLocalSocket::readyRead, [socket](){
            QByteArray cmd = socket->readAll();
            if (cmd == "printHello") {
                qDebug() << "HelloWorld";
            }
            socket->deleteLater();
        });
    });

    return app.exec();
}

App1（客户端）：

#include <QApplication>
#include <QPushButton>
#include <QLocalSocket>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QPushButton btn("触发App2打印");
    btn.show();

    QObject::connect(&btn, &QPushButton::clicked, [](){
        QLocalSocket socket;
        // 连接到服务端
        socket.connectToServer("App2TriggerServer");
        if (socket.waitForConnected(1000)) {
            // 发送触发指令
            socket.write("printHello");
            socket.waitForBytesWritten();
        } else {
            qDebug() << "连接App2失败：" << socket.errorString();
        }
    });

    return app.exec();
}

这个方案只需要依赖Qt Network模块（项目文件加QT += network），代码逻辑简单直接，没有复杂的封装，适合快速实现。

3. TCP/IP方案：其实没你想的复杂 #

如果你以后可能需要扩展到跨机器通信，TCP/IP方案也是不错的选择，Qt的QTcpSocket/QTcpServer封装得非常好，代码和QLocalSocket几乎一样，只是把通信地址换成本地回环127.0.0.1和一个端口号。

App2（服务端）：

#include <QApplication>
#include <QTcpServer>
#include <QTcpSocket>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QTcpServer server;
    if (!server.listen(QHostAddress::LocalHost, 12345)) {
        qDebug() << "服务启动失败：" << server.errorString();
        return 1;
    }

    QObject::connect(&server, &QTcpServer::newConnection, [&](){
        QTcpSocket* socket = server.nextPendingConnection();
        QObject::connect(socket, &QTcpSocket::readyRead, [socket](){
            QByteArray cmd = socket->readAll();
            if (cmd == "printHello") {
                qDebug() << "HelloWorld";
            }
            socket->deleteLater();
        });
    });

    return app.exec();
}

App1（客户端）：

#include <QApplication>
#include <QPushButton>
#include <QTcpSocket>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QPushButton btn("触发App2打印");
    btn.show();

    QObject::connect(&btn, &QPushButton::clicked, [](){
        QTcpSocket socket;
        socket.connectToHost(QHostAddress::LocalHost, 12345);
        if (socket.waitForConnected(1000)) {
            socket.write("printHello");
            socket.waitForBytesWritten();
        } else {
            qDebug() << "连接App2失败：" << socket.errorString();
        }
    });

    return app.exec();
}

这个方案和QLocalSocket的代码几乎一模一样，只是通信方式不同，同样跨平台，而且以后扩展到网络通信也很方便。

关于QSharedMemory轮询方案的弊端 #

你提到的通过定时器轮询QSharedMemory中布尔变量的方式，确实存在不少问题：一是定时器轮询会占用不必要的CPU资源，二是触发有延迟（取决于定时器间隔），三是需要处理变量的原子性问题（避免多进程读写冲突）。除非你的场景极端受限，否则完全不建议用这个方案，上面的几个方案都比它高效、优雅得多。

总结一下：

• 优先选Qt Remote Objects，完全贴合Qt开发习惯，最优雅；
• 追求轻量选QLocalSocket，代码少，无额外模块依赖；
• 需跨机器通信选TCP/IP，逻辑简单，扩展性强。

内容的提问来源于stack exchange，提问作者A. Vieira