Qt moveToThread() vs appelant nouveau thread lorsque nous utilisons à chaque

Quand doit-on utiliser chacun de ces appels de fonction dans un filet d'application.
étant donné deux fonctions fun1() et fun2() définie dans la même classe traitant de lecture/écriture de données dans des tampons(file d'attente de l'opération). pour atteindre le multi-threading pour ces. nous avons à exécuter les deux fonctions dans un thread séparé. maintenant, disons que la première fonction de lecture est appelée au début de son filetage.

est-il préférable d'utiliser moveTothread ( deuxième thread)pour
la fonction d'écriture au début de la première
les fonctions de thread

Ou

définir la seconde fonction dans un nouveau
classe thread et l'appeler le fil à
le début de la première du fil.

InformationsquelleAutor Aditya P | 2011-03-01
  1. 8

    À l'aide de moveToThread nous pouvons changer le fil de l'affinité d'un objet. Ce que l'OP pose est de savoir comment nous pouvons exécuter deux fonctions de la même catégorie dans des threads différents.

    Laissez classe A et deux fonctions f1 et f2

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

    Qt déjà fourni une classe pour l'exécution de fonctions dans différents threads et il est appelé QtConcurrentRun

    La QtConcurrent::run() fonction exécute une fonction dans un thread séparé.
    La valeur de retour de la fonction est mis à disposition par le biais de la QFuture
    L'API.

    La fonction est déclenchée peut être soit une fonction externe ou une fonction de membre. Dans notre cas, si nous voulions partir de l'objet lui-même pour commencer f1 et f2 dans différents threads nous avons pu effectuer les opérations suivantes dans 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);
}

    de même, vous pouvez exécuter toute fonction publique de la catégorie simultanément, par exemple, 

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

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

    Notez la différence entre les deux appels:

    QtConcurrent::run() accepte aussi des pointeurs vers des fonctions de membre du. L'
    premier argument doit être un const référence ou un pointeur vers un
    instance de la classe. Le passage par référence const est utile lorsque
    l'appel de fonctions membres const; passage par pointeur est utile pour
    l'appel de la non-const fonctions de membre qui modifient l'instance.

    Afin de vérifier si une exécuté simultanément la fonction terminée, vous devez utiliser un QFutureWatcher.

    InformationsquelleAutor pnezis
  2. 9

    Comme Piotr répondu, vous devriez vraiment avoir un oeil sur le lien, il suggère.

    Comme je comprends votre problème, ce qui devrait résoudre votre problème.

    C'est la simplification de code de ce blog: 

    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();
}
    • Ce fut une excellente référence pour le problème que j'ai tenté de résoudre. Nice idiomatiques Qt approche.La seule modification que j'ai faite a été de dissocier la consumed() signal de la produce() fente et connecter le producteur finished() signal avec le consommateur finished() signal. De cette façon, le producteur n'a pas à attendre sur le consommateur, et informe les consommateurs quand il est sécuritaire de le quitter.
    InformationsquelleAutor Kurt Pattyn