J'ai un code approximatif que j'ai expérimenté:
somreserver.cpp (une interface graphique) p> travailleur.cpp p> #include "worker.h"
Worker::Worker(QObject *parent) :
QThread(parent)
{
}
void Worker::run()
{
for (;;)
{
// a blocking IO call here like pipe, or msgrcv
// process data received
}
}
5 Réponses :
Vous pouvez bien sûr mettre une valeur booléenne dans la boucle de la boucle dans Probablement mieux consiste à se débarrasser du Travailleur :: Run () Vérifié chaque itération, qui se casse sur == true et est défini par le bouton d'arrêt de l'interface graphique. Bien sûr, cela ne quittera pas le fil pendant que l'exécution est bloquée.
pour en boucle et d'utiliser les signaux et les emplacements de QT pour configurer une fonction de rappel, connecté à un signal comme QioDevice :: Readyead () . Celles-ci seront appelées uniquement lorsqu'il existe des informations disponibles dans la prise / tuyau. Toute autre fois, vous pourrez quitter le thread avec qthread :: sortie () . Vous devrez appeler qthread :: exécuté () à un moment donné pour obtenir la boucle d'événement.
Le problème est que l'appel de blocage est une file d'attente de message System V, donc je ne pense pas que je puisse utiliser quelque chose comme Qiodevice pour configurer une fonction de rappel pour cela.
@Codingdistrict Je ne connais pas avec celles spécifiquement, mais il existe sûrement une sorte d'appareil de rappel pour quand un message est prêt? Cependant, cela fonctionne, je penserais que vous seriez capable de sous-classer qlocalsocket et de faire une enveloppe pour cela.
premier de tous, vous devez définir le parent pour secondaire , le moyen le plus simple de faire ce que vous voulez, c'est de définir une machine à sous qui définira un membre booléen de afin que vous puissiez mettre en constructeur du serveur dans en classe et dans le cycle: après ce signal EMIT Si vous aurez besoin de gestion plus compliquée, arrêtez-vous, vous aurez probablement besoin de protéger votre variable d'état avec un mutex. travailleur pour en faire un enfant d'un autre QOBJECT , pour nettoyer la bonne voie L'application est terminée et la crée sur le tas. c'est-à-dire une voie dynamique. objet de travailleur et vérifiez-le dans chaque cycle pour casser boucle sans fin. N'oubliez pas de connecter cette fente à un signal droit. le long des lignes Server Déclaration de classe: travailleur : Terminator () du serveur quand vous en avez besoin.
Pour arrêter le thread du travailleur, il est nécessaire d'ajouter un drapeau booléen "Arrêter demandé", qui doit être testé au début de chaque itération. De plus, la synchronisation est nécessaire pour lire / écrire la valeur de ce drapeau booléen.
Voici le projet de version: p>
class Worker : public QThread {
public:
Worker() : stopRequested(false) {}
void requestStop()
{
QMutexLocker locker(&mutex);
stopRequested = true;
}
void run()
{
forever
{
if (stopRequested())
break;
// a blocking IO call here like pipe, or msgrcv
// process data received
}
}
private:
bool stopRequested()
{
QMutexLocker locker(&mutex);
return stopRequested;
}
QMutex mutex;
bool stopRequested;
};
Et quel point de synchronisation ici? La systémoscopie n'est pas mieux alors la sous-analyse. De plus, comme @matt Phillips mentionné, cela ne peut pas aider si le thread est bloqué dans l'opération IO.
En outre, il est nécessaire d'ajouter le signal (quelque chose comme "arrêté") à la classe ouvrier et émettez juste après une boucle pour toujours. La classe de niveau d'assurance-emploi doit être connectée au signal et recevoir la notification «arrêtée».
ici vous avez l'explication de Tu es un problème, je pense. Lorsque votre candidature se terminera, vous devriez faire quelque chose comme ceci: wait () est la solution pour votre problème de synchronisation. Vous pouvez également modifier suppression requierStop () à: qmutexocker est important pour éviter une situation d'impasse.
dans la boucle d'infini collez ce code et profitez ...
#include <QCoreApplication> #include <QTime>