linux - 从后台工作线程修改 Qt GUI

Question

我在 Qt 中工作，当我按下 GO 按钮时，我需要不断地将包发送到网络并使用我收到的信息修改界面。

问题是我while(1)在按钮中有一个，所以按钮永远不会完成，所以界面永远不会更新。我想在按钮中创建一个线程并将while(){}代码放在那里。

我的问题是如何从线程修改界面？（例如，如何从线程修改文本框？

Answer 1

关于 Qt 的重要一点是，您必须只能从 GUI 线程（即主线程）使用 Qt GUI。

这就是为什么这样做的正确方法是从worker通知主线程，而主线程中的代码实际上会更新文本框、进度条或其他东西。

我认为最好的方法是使用 QThread 而不是 posix 线程，并使用 Qt信号在线程之间进行通信。这将是您的工人，替代thread_func：

class WorkerThread : public QThread {
    void run() {
        while(1) {
             // ... hard work
             // Now want to notify main thread:
             emit progressChanged("Some info");
        }
    }
    // Define signal:
    signals:
    void progressChanged(QString info);
};

在您的小部件中，定义一个与 .h 中的信号具有相同原型的槽：

class MyWidget : public QWidget {
    // Your gui code

    // Define slot:
    public slots:
    void onProgressChanged(QString info);
};

在 .cpp 中实现这个功能：

void MyWidget::onProgressChanged(QString info) {
    // Processing code
    textBox->setText("Latest info: " + info);
}

现在在你想要生成线程的地方（点击按钮）：

void MyWidget::startWorkInAThread() {
    // Create an instance of your woker
    WorkerThread *workerThread = new WorkerThread;
    // Connect our signal and slot
    connect(workerThread, SIGNAL(progressChanged(QString)),
                          SLOT(onProgressChanged(QString)));
    // Setup callback for cleanup when it finishes
    connect(workerThread, SIGNAL(finished()),
            workerThread, SLOT(deleteLater()));
    // Run, Forest, run!
    workerThread->start(); // This invokes WorkerThread::run in a new thread
}

连接信号和槽后，emit progressChanged(...)在工作线程中发出槽将向主线程发送消息，主线程将在这里调用连接到该信号的槽onProgressChanged。

Ps 我还没有测试过代码，所以如果我在某个地方错了，请随时提出修改建议

Answer 2

因此，机制是您不能从线程内部修改小部件，否则应用程序将崩溃并出现以下错误：

QObject::connect: Cannot queue arguments of type 'QTextBlock'
(Make sure 'QTextBlock' is registered using qRegisterMetaType().)
QObject::connect: Cannot queue arguments of type 'QTextCursor'
(Make sure 'QTextCursor' is registered using qRegisterMetaType().)
Segmentation fault

为了解决这个问题，您需要将线程工作封装在一个类中，例如：

class RunThread:public QThread{
  Q_OBJECT
 public:
  void run();

 signals:
  void resultReady(QString Input);
};

其中 run() 包含您想做的所有工作。

在您的父类中，您将有一个生成数据的调用函数和一个 QT 小部件更新函数：

class DevTab:public QWidget{
public:
  void ThreadedRunCommand();
  void DisplayData(QString Input);
...
}

然后调用线程，你将连接一些插槽，这个

void DevTab::ThreadedRunCommand(){
  RunThread *workerThread = new RunThread();
  connect(workerThread, &RunThread::resultReady, this, &DevTab::UpdateScreen);
  connect(workerThread, &RunThread::finished, workerThread, &QObject::deleteLater);
  workerThread->start();  
}

连接函数有 4 个参数，参数 1 是原因类，参数 2 是该类中的信号。参数3是回调函数的类，参数4是类内的回调函数。

然后你的子线程中有一个函数来生成数据：

void RunThread::run(){
  QString Output="Hello world";
  while(1){
    emit resultReady(Output);
    sleep(5);
  }
}

然后你会在你的父函数中有一个回调来更新小部件：

void DevTab::UpdateScreen(QString Input){
  DevTab::OutputLogs->append(Input);
}

然后当你运行它时，每次在线程中调用发出宏时，父级中的小部件都会更新。如果连接函数配置正确，它将自动获取发出的参数，并将其存储到回调函数的输入参数中。

这是如何工作的：

1. 我们初始化类
2. 我们设置插槽来处理线程完成时发生的事情以及如何处理“返回的”aka emitted 数据，因为我们无法以通常的方式从线程返回数据
3. 然后我们通过->start()调用（硬编码到 QThread 中）运行线程，然后 QT.run()在类中查找硬编码的名称成员函数
4. 每次emit在子线程中调用 resultReady 宏时，它都会将 QString 数据隐藏在线程之间陷入困境的某个共享数据区域中
5. QT 检测到 resultReady 已触发，并通知您的函数 UpdateScreen(QString ) 接受从 run() 发出的 QString 作为父线程中的实际函数参数。
6. 每次触发 emit 关键字时都会重复此操作。

本质上，这些connect()函数是子线程和父线程之间的接口，因此数据可以来回传输。

注意： resultReady() 不需要定义。把它想象成存在于 QT 内部的宏。

Answer 3

您可以使用 invokeMethod() 或 Signals and slots 机制，基本上有很多示例，例如如何发出信号以及如何在 SLOT 中接收信号。但是，InvokeMethod 似乎很有趣。

下面是示例，其中显示了如何从线程更改标签的文本：

//file1.cpp

QObject *obj = NULL; //global 
QLabel *label = new QLabel("test");
obj = label;   //Keep this as global and assign this once in constructor.

接下来在您的 WorkerThread 中，您可以执行以下操作：

//file2.cpp（即线程）

extern QObject *obj;
void workerThread::run()
{
     for(int i = 0; i<10 ;i++
     {
         QMetaObject::invokeMethod(obj, "setText",
                                Q_ARG(QString,QString::number(i)));
     }
     emit finished();
}

Answer 4

您开始线程传递一些指向线程函数的指针（在posix中，线程函数具有签名void* (thread_func)(void*)，在 Windows 下也相等） - 您可以完全自由地将指针发送到您自己的数据（结构或其他东西）并从线程函数中使用它（将指针转换为正确的类型）。好吧，内存管理应该被淘汰（所以你既不会泄漏内存也不会使用已经从线程中释放的内存），但这是一个不同的问题