Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Responsable Qt & Livres

    Thread travailleur avec Qt en utilisant les signaux et les slots
    Qt fournit des classes de threads indépendantes de la plateforme, une manière thread-safe de poster des événements et des connexions entre signaux et slots entre les threads. La programmation multithreadée s'avantage des machines à plusieurs processeurs et est aussi utile pour effectuer les opérations chronophages sans geler l'interface utilisateur d'une application. Sans multithreading, tout est fait dans le thread principal.

    Thread travailleur avec Qt en utilisant les signaux et les slots
    Vous souhaitez participer aux rubriques Qt ou PyQt (tutoriels, FAQ, traductions), HPC ? Contactez-moi par MP.

    Créer des applications graphiques en Python avec PyQt5
    Créer des applications avec Qt 5.

    Pas de question d'ordre technique par MP !

  2. #2
    Rédacteur

    Bon tuto.
    Mais dommage qu'il reimplémente un QThread. Pourquoi?
    Par ce que cette méthode sert aussi à partager un thread entre plusieurs QObject et donne la possibilité d'équilibrer l'exécution des threads.

    J'aurais fais cela :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    /*! Classe pour effectuer le travail (tri) dans un thread travailleur. */
    class Sorter : public QObject {
      Q_OBJECT
     
    public:
     
      Sorter(QObject *parent = 0)
          :QObject(parent)
      {
           qRegisterMetaType< QVector<int> >("QVector<int>");
          connect(this,SIGNAL(sortingRequested( QVector<int>)),this,SLOT(sortAsync( QVector<int>)));
      }
    public slots:
      /*! Trie de manière asyncrhone un vecteur dans le thread travailleur. */
      void sortAsync(const QVector<int> &list)
      {
          //si on est pas dans le bon thread, on bouge l'appel dans le thread
          if(thread() != QThread::currentThread () )
          {
              sortingRequested(list);
              return ;
          }
     
          QVector<int> v_sorted = v;
          qSort(v_sorted);
          emit vectorSorted(v_sorted);
      }
     
    signals:
      /*! Signal interne utilisé pour communiquer avec le thread travailleur. */
      void sortingRequested(const QVector<int> &list);
      /*! Signal émis quand le vecteur est trié. */
      void vectorSorted(const QVector<int> &list);
     
     
    };

    Et si on veux qu'il s’exécute dans un thread particulier, il suffit d'utiliser movetothread.

    PS : Par défaut, Qthread lance son eventloop.