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

Question

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

我尝试创建一个 DLL，它是我们 USB 设备的 API。该库也应该适用于非 Qt 应用程序。我有 PIMPL 编辑的所有 Qt 东西和私有类，所以下面的代码是公共类下的一层。我正在使用 QSerialPort 和很多 SIGNAL/SLOT，所以我需要 QCoreApplications 事件循环。 ReaderSerial 是 Qt 东西开始的地方，它还实例化另一个类，其中 QSerialPort 在不同的 QThread 中运行。

此时我的问题是整个事情都因错误而崩溃：“QTimer can only be used with threads started with QThread”

我猜像 ReaderSerial 这样的基于 Qt 的类不会“看到”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();
};

reader.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;
};

appthread.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.
};

appthread.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。在内部，您只需将事件发布到您的任何QObjects。您还可以将QMetaObject::invokeMethod 与Qt::QueuedConnection 一起使用——它最终只是将QMetaCallEvent 发布到目标对象。事件可以从任何线程发布到任何QObject，包括非QThread-started-threads。

2. 外部线程回调：指定一个单独的线程，消费者提供的回调在其中执行。它们会被该线程中的一个或多个QObjects 调用。

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

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

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

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

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

所有 API 必须为 extern C，且不得使用 C++。如果您计划使用多个 VS 版本（例如 2008、2010、2012、2013）构建 DLL，则只能提供 C++ API——即使如此，您也不能将 Qt 暴露给消费者，因为消费者可能仍然使用二进制不兼容的版本。

Answer 2

QtWinMigrate 解决了 Qt 在 Win32 或 MFC 中的事件循环问题。 answers 到question you reference 之一提到了这一点。

对于需要在 DllMain 中链接事件循环的 Qt DLL，只需使用 QMfcApp::pluginInstance