如何使用多线程制作一个简单的 Qt 控制台应用程序？

Question

我很难理解如何使最简单的工作 多线程 Qt 控制台 应用程序。

我已经阅读了大量关于如何使用 QThread 类的资料。 他们中的一些人说是 QThread 的子类，其他人说使用 QThread 的工作类包装器。

经过多次尝试和重试后，我仍然无法使多线程工作 Qt 控制台应用程序。

现在我不需要任何花哨的 Qt Gui。

有人可以帮我填写示例代码的线程部分吗？ 它一次只从文本文件中读取一行，其想法是目前不忙的每个线程（我想使用 4 个线程）将尽快使用 std::cout 将该行打印到标准输出。只需打印它，暂时没有其他花哨的处理东西可以让我保持简单。

#include <QCoreApplication>
#include <QFile>
#include <iostream>

/* QThread stuff here */
/* Don't know how to make it */

int main(int argc, char *argv[])
{
        QCoreApplication a(argc, argv);

        /* Create four instances of threads here and 
           put them to wait readed lines */

    QFile   file("file.txt");
    file.open(QIODevice::ReadOnly | QIODevice::Text);

    while(!file.atEnd()) {
    /* Read lines here but where should they be saved?
       Into a global variable like QList<QByteArray> list ?
       So that each thread can read them from there or where ???? */

       ??? = file.readLine(); 
    }
    file.close();
    a.exit();
}

Answer 1

将功能放入 QObject 的插槽中

重点是：

1. 请记住，每个QObject 都有一个特定的thread()，它“生活”在其中。每个线程都可以在那里运行一个事件循环。这个事件循环会将发送的事件传递给在这个线程中“存活”的对象。

2. 不要从QThread 派生。开始库存QThreads。他们将在QThread::run() 的默认实现中启动一个偶数事件循环。

3. 在插槽（或Q_INVOKABLE）方法中实现您的功能。该类显然必须从 QObject 派生。

4. 当您将信号（使用信号槽连接，而不是直接）发送到 #3 中的槽时，就会发生魔法。从运行在 GUI 线程中的通知程序到被通知对象的连接是使用 Qt::QueuedConnection 自动完成的，因为发送方和接收方对象位于不同的线程中。

   向这样的对象发送信号会导致将事件发送到对象所在线程的事件队列。事件循环的事件分派器将选择这些事件并调用适当的插槽。这就是 Qt 的强大之处——可以为您做很多有用的事情。

请注意，没有“当前繁忙”线程的概念。线程执行住在那里的对象的短槽。如果您想在“忙”和“不忙”状态之间移动线程，那么您需要额外的代码。

实现它的另一种方法是从QRunnable 派生并使用QThreadPool。这是另一个答案。

ma​​in.cpp

#include <QCoreApplication>
#include <QTextStream>
#include <QThread>
#include <QFile>
#include <cstdio>

class Notified : public QObject {
    Q_OBJECT
    QTextStream m_out;
public:
    Q_SLOT void notify(const QString & text) {
        m_out << "(" << this << ") " << text << endl;
    }
    Notified(QObject *parent = 0) : QObject(parent), m_out(stdout) {}
};

class Notifier : public QObject {
    Q_OBJECT
    Q_SIGNAL void notification(const QString &);
public:
    Notifier(QObject *parent = 0) : QObject(parent) {}
    void notifyLines(const QString & filePath) {
        QFile file(filePath);
        file.open(QIODevice::ReadOnly | QIODevice::Text);
        while (! file.atEnd()) {
            emit notification(file.readLine());
        }
        file.close();
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    QObjectList notifieds;
    QList<QThread*> threads;
    Notifier notifier;

    for (int i = 0; i < 4; ++i) {
        QThread * thread = new QThread(&a); // thread owned by the application object
        Notified * notified = new Notified; // can't have an owner before it's moved to another thread
        notified->moveToThread(thread);
        thread->start();
        notifieds << notified;
        threads << thread;
        notified->connect(&notifier, SIGNAL(notification(QString)), SLOT(notify(QString)));
    }

    notifier.notifyLines("file.txt");

    foreach (QThread *thread, threads) {
        thread->quit();
        thread->wait();
    }
    foreach (QObject *notified, notifieds) delete notified;

    a.exit();
}

#include "main.moc"

Answer 2

出于您的目的，我根本不会使用 QThread，而是使用来自 QtConcurrent 的类。

一些简单的东西（假设你有 C++11）：

  while(!file.atEnd()) {

   QString line = file.readLine(); 

   QtConcurrent::run([line] 
       { 
         qDebug() << line; 
       }); 
   }

虽然我仍然不确定这会给你带来什么。

Answer 3

下面的链接可能对您在 Qt 中使用线程相关的信息有用

http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/

如果您只想以异步方式完成文件读取，Qt 有几种替代技术，例如 QtConcurrent。

http://qt-project.org/doc/qt-4.8/threads-qtconcurrent.html

这里有一些示例代码可以帮助您使用 QtConcurrent

在单独的线程中运行函数

 extern QString aFunction();
 QFuture<void> future = QtConcurrent::run(aFunction);

aFunction 应该包含读取文件的代码。

可以通过以下方式返回读取的数据

QFuture<QString> future = QtConcurrent::run(aFunction);
 ...
QString result = future.result();

请注意，QFuture::result() 函数会阻塞并等待结果可用。当函数执行完毕且结果可用时，使用 QFutureWatcher 获取通知。

希望这会有所帮助。以上代码均取自Qt文档。

Answer 4

将功能放入 QRunnable

也许最接近您明确需求的解决方案将使用QThreadPool。它做你想做的事：它从它的池中挑选一个不忙的线程，并在那里运行工人。如果没有空闲线程，它会将可运行线程添加到运行队列中，每次空闲线程可用时都会耗尽。

但请注意，您明确希望拥有一个线程状态（即忙/非忙）与需要在尝试每个新密码之前等待回复的网络渗透系统完全不匹配。你会想要它基于QObjects。我将修改我的其他答案，以展示您在管理网络连接时如何做到这一点。将线程浪费在忙于等待网络答案上是非常非常浪费的。你确实不想要那样做。效果会很差。

您的应用程序受 I/O 限制，几乎可以在一个线程上运行，而不会造成过多的性能损失。只有当您拥有庞大的网络管道并且同时测试数万个帐户时，您才需要多个线程。我是认真的。

#include <QCoreApplication>
#include <QTextStream>
#include <QRunnable>
#include <QThreadPool>
#include <QFile>
#include <cstdio>

class Data : public QString {
public:
    Data(const QString & str) : QString(str) {}
};

class Worker : public QRunnable {
    QTextStream m_out;
    Data m_data;
public:
    void run() {
        // Let's pretend we do something serious with our data here
        m_out << "(" << this << ") " << m_data << endl;
    }
    Worker(const Data & data) : m_out(stdout), m_data(data) {}
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    QThreadPool * pool = QThreadPool::globalInstance();

    QFile file("file.txt");
    file.open(QIODevice::ReadOnly | QIODevice::Text);
    while (! file.atEnd()) {
        const Data data(file.readLine());
        Worker * worker = new Worker(data);
        pool->start(worker);
    }
    file.close();
    pool->waitForDone();
}