c++ - 非 Qt 应用程序中基于 Qt 的 DLL 中的事件循环

Question

我在整个网络上搜索答案，但没有找到解决我的问题的方法。或者也许我理解了，但因为我是 C++/编程/Qt 的初学者，所以我不理解它们。最接近的是这里的问题Using a Qt-based DLL in a non-Qt application .我尝试使用这种方法，但到目前为止没有成功。

我尝试创建一个 DLL，它是我们 USB 设备的 API。该库也应该适用于非 Qt 应用程序。我已经对所有 Qt 内容和私有(private)类进行了 PIMPL，因此下面的代码是公共(public)类下的一层。我正在使用 QSerialPort 和大量 SIGNAL/SLOT，所以我需要 QCoreApplications 事件循环。 ReaderSerial 是 Qt 开始的地方，它还实例化另一个类，其中 QSerialPort 在不同的 QThread 中运行。

此时我的问题是整个程序因错误而崩溃:“QTimer 只能用于以 QThread 启动的线程”

我想我的基于 Qt 的类(如 ReaderSerial)不会“看到”QCoreApp 事件循环或类似的东西。所以我的问题是如何为我的 DLL 提供 QCoreApplication 事件循环，这样我创建的所有基于 Qt 的类都可以工作，并且我将能够从我的 DLL 中调用方法。

非常感谢您的回答。

reader_p.h

class ReaderPrivate
{
public:
   ReaderPrivate();
   ~ReaderPrivate();

   void static qCoreAppExec();

   ReaderSerial *readerSerial;

   void connectReader(std::string comPort);
   void disconnectReader();
};

阅读器.cpp

// Private Qt application
namespace QAppPriv
{
    static int argc = 1;
    static char * argv[] = {"API.app", NULL};
    static QCoreApplication * pApp = NULL;
};

ReaderPrivate::ReaderPrivate()
{
    std::thread qCoreAppThread(qCoreAppExec);
    qCoreAppThread.detach();

    readerSerial = new ReaderSerial;
}

ReaderPrivate::~ReaderPrivate()
{

    delete readerSerial;

}

void ReaderPrivate::qCoreAppExec()
{
    if (QCoreApplication::instance() == NULL)
    {
        QAppPriv::pApp = new QCoreApplication(QAppPriv::argc, QAppPriv::argv);
        QAppPriv::pApp->exec();
        if (QAppPriv::pApp)
            delete QAppPriv::pApp;
    }
}

void ReaderPrivate::connectReader(std::string comPort)
{
    readerSerial->openDevice(comPort);
}

void ReaderPrivate::disconnectReader()
{
    readerSerial->closeDevice();
} 

基于@Kuba Ober 的回答，我创建了一个共享库。我花了一些时间来理解发生了什么以及如何让它工作，但它仍然没有做它应该做的事情。所以我现在寻求建议如何使这段代码工作。

apic.h

#include "Windows.h"

extern "C"
{
    __declspec(dllexport) void WINAPI kyleHello();
}

apic.cpp

#include "apic.h"
#include "appthread.h"

void WINAPI kyleHello()
{
    worker->hello();
}

BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID)
{
    static AppThread *thread;

    switch (reason)
    {
    case DLL_PROCESS_ATTACH:
        thread = new AppThread;
        thread->start();
        break;
    case DLL_PROCESS_DETACH:
        delete thread;
        break;
    default:
        break;
    }

    return TRUE;
};

应用线程.h

#include <QThread>
#include <QCoreApplication>
#include <QPointer>

#include "worker.h"

static QPointer<Worker> worker;

class AppThread : public QThread
{
public:
    AppThread();
    ~AppThread();

    // No need for the Q_OBJECT
    QPointer<QCoreApplication> m_app;

    void run() Q_DECL_OVERRIDE
    {
        std::cout << "\n AppThread::run";

        int argc;
        char *argv;

        QCoreApplication app(argc, &argv);

        m_app = &app;

        std::cout << "\nAppThread::run before Worker";
        Worker worker_;
        worker = &worker_;

        std::cout << "\nAppThread::run before app.exec";
        app.exec();
    }

    //using QThread::wait(); // This wouldn't work here.
};

应用线程.cpp

#include "appthread.h"

AppThread::AppThread()
{
    std::cout << "\n AppThread::ctor";
}

AppThread::~AppThread()
{
    std::cout << "\n AppThread::dtor \n";
    m_app->quit();
    wait();
}

worker .h

#include <QObject>
#include <QDebug>
#include <iostream>

class Worker : public QObject
{
    Q_OBJECT
    Q_INVOKABLE void helloImpl()
    {
        std::cout << "I'm alive.";
        //qDebug() << "I'm alive.";
    }

public:
    Worker();

    void hello();
};

worker .cpp

#include "worker.h"

Worker::Worker()
{
    std::cout << "\nWorker::ctor";
    hello();
}

void Worker::hello()
{
    std::cout << "\nWorker::hello()";
    // This is thread-safe, the method is invoked from the event loop
    QMetaObject::invokeMethod(this, "helloImpl", Qt::QueuedConnection);
}

这个的输出通常是:

AppThread::ctor  
Worker::hello()  
AppThread::dtor  

有时:

AppThread::ctor  
Worker::hello()  
AppThread::run  
AppThread::dtor  

有时:

AppThread::ctor  
Worker::hello()  
AppThread::dtor  
QMutex: destroying locked mutex

GitHub 存储库:https://github.com/KyleHectic/apic.git

Answer 1

首先，如果您需要QCoreApplication，它将始终是您的 QCoreApplication。您应该不尝试在您的 DLL 中对 Qt 进行任何类型的动态链接，以防它最终从您的消费者应用程序中获取 Qt。不能保证这些 Qt 库之间的二进制兼容性——这将迫使您的消费者使用完全相同的编译器版本和 Qt 的二进制兼容版本。也就是说，一般来说，是一种幻想。

因此，您需要测试 QCoreApplication 是否存在的想法根本不适合您的使用模型。你将永远需要它。您所要做的就是启动一个线程并在那里启动核心应用程序。就是这样。

QPointer<Worker> worker;

extern "C" {
  __declspec(DLLEXPORT) WINAPI VOID kyleHello() {
    worker->hello();
  }
}

class Worker() : public Q_OBJECT {
  Q_OBJECT
  Q_INVOKABLE void helloImpl() { qDebug() << "I'm alive."; }
public:
  void hello() {
    // This is thread-safe, the method is invoked from the event loop
    QMetaObject::invokeMethod(this, "helloImpl", Qt::QueuedConnection);
  } 
  Worker() { hello(); }
};

class AppThread : public QThread {
  // No need for the Q_OBJECT
  QPointer<QCoreApplication> m_app;
  void run() Q_DECL_OVERRIDE {
    int argc; 
    char * argv;
    QCoreApplication app(argc, &argv);
    m_app = &app;
    Worker worker_;
    worker = &worker_;
    app.exec();
  }
  using QThread::wait(); // This wouldn't work here.
public:
  AppThread() {}
  ~AppThread() { m_app->quit(); wait(); }
}

BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID) {
  static AppThread * thread;
  switch (reason) {
  case DLL_PROCESS_ATTACH:
    thread = new AppThread;
    thread->start();
    break;
  case DLL_PROCESS_DETACH:
    delete thread;
    break;
  default:
    break;
  }
  return TRUE;
}

向您的消费者公开的 API 有几种:

1. 不等待结果的只写 API。在内部，您只需将事件发布到您的任何 QObject 即可。您还可以将 QMetaObject::invokeMethod 与 Qt::QueuedConnection 一起使用 - 它最终只是将 QMetaCallEvent 发送到目标对象。事件可以从任何线程发布到任何 QObject，包括非 QThread 启动的线程。

2. 外部线程回调:专门用于执行消费者提供的回调的单独线程。它们会被该线程中的一个或多个 QObject 调用。

3. 客户端线程回调:使用特定于平台的 asynchronous procedure calls在任何线程的上下文中执行回调 - 通常是调用回调注册函数的线程。这些回调在线程处于可警报状态时执行。

   如果您希望将自己限制在运行消息泵(调用 GetMessage)的可警报状态的子集内，您可以创建一个 message-only, invisible window ，向其发送消息，并从窗口的回调函数发出消费者回调。如果你很聪明，你可以通过这些消息传递 QEvent 指针，并将它们传递给回调中的 QObject::event。这就是如何使 QObject 有效地存在于具有 native 事件循环且没有运行 Qt 事件循环的线程中。

4. 有效地将调用线程与您的线程同步的阻塞 API:将 QMetaObject::invokeMethod 与 Qt::BlockingQueuedConnection 结合使用。调用者将等待槽在接收线程中完成执行，并可选择将结果传回。

5. 阻止使用细粒度锁定的 API。这些也将调用者线程同步到您的线程，但仅在锁定某些数据结构的级别。这些主要用于读取参数或提取数据 - 当通过事件循环的开销会使您执行的少量工作相形见绌时。

您提供哪些 API 取决于您的 API 的设计标准。

所有 API 都必须是 extern C 并且不得使用 C++。如果您计划使用多个 VS 版本(比如 2008、2010、2012、2013)构建 DLL，则只能提供 C++ API——即便如此，您也不得向消费者公开 Qt，因为消费者可能仍使用二进制不兼容的版本。