Qt moveToThread()vs我们使用每个时调用新线程

Question

我们什么时候在线程应用程序中使用每个函数调用.给定两个函数fun1()和fun2()在同一个类中定义处理数据到缓冲区的读/写(队列操作).实现对这些的多线程.我们必须在一个单独的线程中运行这两个函数.现在假设第一个函数read在其线程的开头被调用.

最好在第一个函数线程的开头使用moveTothread(第二个线程)进行函数写入

要么

在新线程类中定义第二个函数,并在第一个线程的开头调用该线程.

Answer 1

像Piotr回答你应该看看他建议的链接.
据我了解你的问题,这应该可以解决你的问题.
这是该博客的简化代码:

class Producer  
{  
public:
    Producer();  

public slots:
    void produce()
    { //do whatever to retrieve the data
      //and then emit a produced signal with the data
      emit produced(data);
      //if no more data, emit a finished signal
      emit finished();
    }

signals:
    void produced(QByteArray *data);
    void finished();
};

class Consumer
{
public:
    Consumer();

public slots:
    void consume(QByteArray *data)
    {
       //process that data
       //when finished processing emit a consumed signal
       emit consumed();
       //if no data left in queue emit finished
       emit finished();
    }
};

int main(...)
{
    QCoreApplication app(...);

    Producer producer;
    Consumer consumer;

    producer.connect(&consumer, SIGNAL(consumed()), SLOT(produce()));
    consumer.connect(&producer, SIGNAL(produced(QByteArray *)), SLOT(consume(QByteArray *));

    QThread producerThread;
    QThread consumerThread;
    producer.moveToThread(&producerThread);
    consumer.moveToThread(&consumerThread);

    //when producer thread is started, start to produce
    producer.connect(&producerThread, SIGNAL(started()), SLOT(produce()));

    //when consumer and producer are finished, stop the threads
    consumerThread.connect(&consumer, SIGNAL(finished()), SLOT(quit()));
    producerThread.connect(&producer, SIGNAL(finished()), SLOT(quit()));

    producerThread.start();
    consumerThread.start();

    return app.exec();
}

Answer 2

使用moveToThread我们可以改变对象的线程亲和力.OP问的是我们如何在不同的线程中运行同一个类的两个函数.

让类A和两个函数f1和f2

class A
{
public:
    void f1();
    void f2(int i); 
    void run(); // shows how we can trigger f1 and f2 in different threads
}

Qt 已经提供了一个用于在不同线程中运行函数的类,并且它被调用 QtConcurrentRun

该QtConcurrent::run()函数在单独的线程中运行函数.函数的返回值可通过QFuture API获得.

触发的函数可以是外部函数或成员函数.因此,在我们的情况下,如果我们想要从对象本身开始f1并f2在不同的线程中,我们可以执行以下操作run()

void run()
{
   // QFuture<void> because f1 is void 
   QFuture<void> future1 = QtConcurrent::run(this, &A::f1);
   int k = 5; // Concurrent run with arguments
   QFuture<void> future2 = QtConcurrent::run(this, &A::f2, k);
} 

类似地,您可以同时执行任何类的任何公共函数,例如

QImage image = ...;
QFuture<void> future = QtConcurrent::run(image, &QImage::invertPixels, QImage::InvertRgba);

A a;
QFuture<void> future1 = QtConcurrent::run(A, &A::f1);

注意两个调用之间的区别:

QtConcurrent::run()也接受指向成员函数的指针.第一个参数必须是const引用或指向该类实例的指针.在调用const成员函数时,通过const引用传递是很有用的.传递指针对于调用修改实例的非const成员函数很有用.

为了检查同时执行的函数何时完成,你应该使用a QFutureWatcher.