Comment émettre de la croix-fil de signal dans Qt?

Qt documentation indique que les signaux et les slots peuvent être direct, queued et auto.

Il a également déclaré que si l'objet qui possède la fente " vit " dans un thread différent de l'objet qui possède signal, émission de ces signaux sera comme message d'affectation de signal d'émettre sera de retour instantanément et fente méthode sera appelée dans le thread cible de la boucle d'événements.

Malheureusement, la documentation ne précise pas que les "vies" et pas d'exemples est disponible. J'ai essayé le code suivant:

main.h:

class CThread1 : public QThread
{
Q_OBJECT
public:
    void run( void )
    {
        msleep( 200 );
        std::cout << "thread 1 started" << std::endl;
        MySignal();
        exec();
    }
signals:
    void MySignal( void );
};

class CThread2 : public QThread
{
Q_OBJECT
public:
    void run( void )
    {
        std::cout << "thread 2 started" << std::endl;
        exec();
    }
public slots:
    void MySlot( void )
    {
        std::cout << "slot called" << std::endl;
    }
};

main.cpp:

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    CThread1 oThread1;
    CThread2 oThread2;
    QObject::connect( & oThread1, SIGNAL( MySignal() ),
        & oThread2, SLOT( MySlot() ) );
    oThread1.start();
    oThread2.start();
    oThread1.wait();
    oThread2.wait();
    return a.exec();
}

De sortie est:

thread 2 started
thread 1 started

MySlot() n'est jamais appelée :(. Ce que je fais mal?

InformationsquelleAutor grigoryvp | 2009-03-12
  1. 46

    Il y a pas mal de problèmes avec votre code :

    • comme dit par Evan le émettent mot-clé est manquante
    • tous vos objets de vivre dans le thread principal, seul le code de l'exécution des méthodes vivre dans d'autres threads, ce qui signifie que le MySlot logement serait appelé dans le thread principal et je ne suis pas certain de ce que vous voulez
    • votre logement ne sera jamais appelé depuis la boucle principale ne seront jamais lancé : vos deux appels à la fonction wait() ne timeout après un temps très long (et vous aurez probablement tuer votre demande avant que cela arrive) et je ne pense pas que c'est ce que vous voulez, de toute façon ils n'ont vraiment pas d'utiliser dans votre code.

    Ce code serait le plus susceptible de travailler (même si je ne l'ai pas testé) et je pense que c'est ce que vous voulez faire :

    class MyObject : public QObject
{
    Q_OBJECT
public slots:
    void MySlot( void )
    {
        std::cout << "slot called" << std::endl;
    }
};

class CThread1 : public QThread
{
    Q_OBJECT
public:
    void run( void )
    {
        std::cout << "thread 1 started" << std::endl;
        int i = 0;
        while(1)
        {
           msleep( 200 );
           i++;
           if(i==1000)
              emit MySignal();
        }
    }
signals:
    void MySignal( void );
};

class CThread2 : public QThread
{
    Q_OBJECT
public:
    void run( void )
    {
        std::cout << "thread 2 started" << std::endl;
        exec();
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    CThread1 oThread1;
    CThread2 oThread2;
    MyObject myObject;
    QObject::connect( & oThread1, SIGNAL( MySignal() ),
        & myObject, SLOT( MySlot() ) );
    oThread2.start();
    myObject.moveToThread(&oThread2)
    oThread1.start();
    return a.exec();
}

    Maintenant MyObject vivra dans thread2 (grâce à moveToThread).

    MySignal doivent être envoyées à partir thread1 (la pensée, je ne suis pas sûr que l'un, cela pourrait être envoyés à partir de thread principal, il n'a pas vraiment d'importance).

    Aucun cas, la boucle est nécessaire dans thread1 depuis émettant un signal n'a pas besoin d'une boucle d'événements. Une boucle est nécessaire dans thread2 (lanched par exec()) pour recevoir le signal.

    MySlot sera appelée dans thread2.

    • est-il un moyen de connecter un slot signal avant de threads sont lancés? Je ne veux pas le fils d'émettre quelque chose avant que tout est connecté.
    • Dans mon exemple, la connexion est faite avant que le thread qui effectue le émettent est commencé. Je suis en attente jusqu'à 1000 juste pour le plaisir 😉
    • Merci, moveToThread fonctionne avant de tout thread est démarré. bien sûr, myThread.moveToThread( & myThread ); l'air un peu bizarre, mais fonctionne très bien.
    • À strictement parler, qu'ils utilisent ou non le émettent un "mot clé" ne devrait pas affecter quoi que ce soit. Il est défini à un vide de macro.
    • Que faire si le signal est émis à partir d'un non-qt thread (c'est à dire qu'un thread créé avec boost), est-ce un problème ou est-ce même possible? Par exemple, si j'ai un non-qt serveur de réseau de classe qui peut invoquer des rappels à partir de son filetage interne, lors de la réception de messages, et je veux dans un projet QT et l'itinéraire de ces rappels à des slots de QT.
    InformationsquelleAutor Aiua
  2. 36

    Ne pas sous-classe QThread pour Qt 4.4+

    Tout Aiua la réponse est bonne, je tiens à souligner quelques problèmes avec QThread et Qt 4.6 ou 4.7.

    Cet article, il résume: http://blog.qt.io/blog/2010/06/17/youre-doing-it-wrong/

    Manque de Documentation sur l'intervalle Qt est une partie

    Malheureusement, le problème vient d'un manque de mises à jour de la documentation. Avant de Qt 4.4 QThread avait pas de valeur par défaut run() de la mise en œuvre, ce qui signifiait que vous aviez à la sous-classe QThread pour l'utiliser.

    Si vous êtes à l'aide de Qt 4.6 ou 4.7 puis vous avez presque certainement devrait pas sous-classe QThread.

    Utilisation moveToThread

    La clé pour obtenir les fentes à exécuter dans un thread de travail est d'utiliser la moveToThread méthode Aiua a souligné.

    • Sous-classement QThread et dominante run() est pris en charge par Qt. C'est même la première solution proposée par Qt sur cette table. Cependant, cela ne devrait être utilisé que lorsqu'aucun événement boucle est nécessaire pour le thread. En particulier, si quelqu'un à besoin d'appeler moveToThread(this); à l'intérieur du fil, comme indiqué dans l'article lié, il l'utilise à tort.
    • C'était la recommandation officielle, jusqu'à ce que cet article est sorti: woboq.com/blog/qthread-you-were-not-doing-so-wrong.html j'ai mis en place le filetage de cette façon, et il est très léger. Stable comme un réservoir. Pas de moveToThread. Pas de supplément QObjects alloué. Vous pouvez en effet mettre travailleur code dans la fonction run () (ou de l'appeler à partir de là). Maintenant, ils ont officiellement en charge.
    InformationsquelleAutor Will Bickford
  3. 0

    vous devez émettre le signal de départ de votre fonction de thread comme 

    emit operateCut(examId,examName_examTemplate[examName].studentIdRec,examName_examTemplate[examName].choiceRecA,examName_examTemplate[examName].choiceRecB,examName_examTemplate[examName].objectRecA,examName_examTemplate[examName].objectRecB);

    vous pouvez ajouter plus d'un argument dans ce signal

    InformationsquelleAutor kuake56