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

Question

我在整个网络上搜索答案,但没有找到我的问题的解决方案.或许我做了,但因为我是C++/programming/Qt的初学者,我不理解它们.最接近的问题是在非Qt应用程序中使用基于Qt的DLL.我试图使用这种方法,但到目前为止还没有成功.

我尝试创建一个DLL,它是我们的USB设备的API.该库也应该适用于非Qt应用程序.我有PIMPL-ed所有Qt的东西和私有类,所以下面的代码是公共类下的一层.我正在使用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();
};

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。在内部，您只需将事件发布到您的任何一个QObject。您还可以使用QMetaObject::invokeMethodwith a Qt::QueuedConnection- 它最终只是将 a 发布QMetaCallEvent到目标对象。事件可以从任何线程发布到任何QObject线程，包括非 QThread 启动的线程。

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

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

   如果您希望将自己限制在消息泵运行（GetMessage被调用）的可警报状态的子集，您可以创建一个仅消息、不可见的窗口，向其发布消息，并从窗口的回调函数发出消费者回调。如果您很聪明，您可以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，因为使用者可能仍然使用二进制不兼容的版本。