QThreads , QObject et de la fonction de veille

La réponse est simple: vous n'êtes pas censé bloquer asynchrone, de l'exécution à l'achèvement de code, chaque gestionnaire d'événement et la fente de la mise en œuvre de QObject est censé faire son travail et à renvoyer dès que possible. Il n'est pas censé faire toute sorte de occupé attente ou de sommeil. Pour plus d'rodomontades le long de cette ligne, voir Miro Samek de Je déteste RTOSes.

Pour une bien meilleure mise en œuvre qui résulte de ce qui précède, voir cette réponse à la place. Macro astuces qui suit ci-dessous est préférable de laisser les pauvres âmes coincé avec C.

J'ai joint un exemple de la façon de faire de la bonne façon, au moins du point de vue de ce que fait le code. Si vous voulez une mise en œuvre réelle, ne cherchez pas plus loin que Du coup de pouce stackless coroutines.

La macro ruse est sucre syntaxique - il fait de la technique le plus agréable au goût (Boost t-il mieux que je le fais ci-dessous). Si vous utilisez des macros ou d'écrire les méthodes explicitement, c'est à vous. La syntaxe est pas ce qui est prétendu être la "bonne façon" de faire. Je suis pas le seul à utiliser ces préprocesseur supercherie. Manque, c'est le soutien des appels de fonctions imbriquées, et plusieurs "threads" de l'exécution à l'achèvement d'exécution au sein d'un QObject. Le montre l'exemple de code pour un seul "fil" et un seul niveau de async appels de fonction. Stackless Python prend cela à la conclusion logique.

Vous verrez ce modèle dans tous de votre code si vous l'écrire de manière asynchrone. Le SLEEP macro est la syntaxe de sucre pour aider à rendre le code plus facile à suivre. Il n'y a pas vraiment propre façon de l'écrire sans hacky macro en C++ où la syntaxe ne serait pas dominateur. Même en C++11, la langue n'a pas de prise en charge intégrée pour le rendement. Voir Pourquoi n'était-ce pas le rendement ajoutée pour C++0x?.

C'est vraiment non-blocage de code, vous verrez que le périodique de l'événement timer se déclenche pendant que vous êtes "endormi". Notez que cet multitâche coopératif a beaucoup moins de frais généraux que le thread/processus de bascule fait par le système d'exploitation. Il ya une raison pourquoi les 16 bits de Windows de l'application du code a été écrit de cette manière: il exécute très bien, même sur les maigres matériel.

Noter que ce code ne pas besoin d'un QThread, et, en fait, ne pas utiliser de QThread, bien que si vous voulez déplacer l'objet vers un thread de priorité élevée, les retards aura moins de propagation.

L'intervalle Qt de la minuterie de mise en œuvre est assez intelligent pour diminuer le timer tick période sous Windows, si la période est "court". Vous pouvez utiliser la plate-forme spécifique code que j'ai montré ci-dessous, mais il devrait être découragé. Sur Qt 5, il vous suffit de démarrer une Qt::PreciseTimer de la minuterie. Notez que sur la pré-Windows 8 de systèmes de négociation hors la consommation d'énergie et légèrement plus élevé dans le noyau de frais généraux pour les performances ici. Windows 8, OS X (xnu) et moderne Linux sont tickless et ne pas souffrir d'une telle dégradation de la performance.

Je doit reconnaître que le clair de préprocesseur abus direction de La création de C macro ## et __LINE__ (jeton de concaténation avec le positionnement de la macro).

De même pour la SLEEP() macro, vous pouvez également mettre en place un GOTO() macro, pour vous permettre d'avoir simple des machines à états finis qui sont écrits dans un format plus facile à suivre sur le blocage de style de code, mais sont asynchrones derrière les coulisses. Vous pouvez avoir ENTER() et LEAVE() des macros pour mettre en œuvre des actions à faire sur l'état d'entrée et de sortie, etc, mais le code peut regarder tout à fait comme un droit codée blocage de style de fonction. J'ai trouvé ça assez productif, et plus facile à suivre que le code qui est dépourvue de toute syntaxique sugarcoating. YMMV. En fin de compte, vous auriez quelque chose qui est sur le chemin de UML diagrammes d'états-transitions, mais avec moins de frais généraux (tous les deux d'exécution de code et de texte-sage) que QStateMachine-based implémentations.

Ci-dessous est la sortie, les astérisques sont minuteur périodique par les tiques.

doing something
*
*
*
*
*
*
*
*
*
*
slept, a=10
*
*
*
*
*
slept, a=20
*
*
slept, a=30
*
slept, a=40

#sleep.pro
QT       += core
QT       -= gui
TARGET = sleep
CONFIG   += console
CONFIG   -= app_bundle
TEMPLATE = app
SOURCES += main.cpp

//main.cpp
#ifdef Q_WS_WIN
#include <windows.h>
#endif
#include <cstdio>
#include <QtCore/QTextStream>
#include <QtCore/QObject>
#include <QtCore/QBasicTimer>
#include <QtCore/QTimer>
#include <QtCore/QCoreApplication>
QTextStream out(stdout);
//this order is important
#define TOKENPASTE2(x,y) x ## y
#define TOKENPASTE(x,y) TOKENPASTE2(x,y)
#define SLEEP(ms) sleep(ms, &SLEEPCLASS::TOKENPASTE(fun, __LINE__)); } void TOKENPASTE(fun, __LINE__)() {
class Object : public QObject
{
Q_OBJECT
#define SLEEPCLASS Object //used by the SLEEP macro
public:
Object() {
QTimer::singleShot(0, this, SLOT(slot1()));
periodic.start(100);
connect(&periodic, SIGNAL(timeout()), SLOT(tick()));
}
protected slots:
void slot1() {
a = 10; //use member variables, not locals
out << "doing something" << endl;
sleep(1000, &Object::fun1);
}
void tick() {
out << "*" << endl;
}
protected:
void fun1() {
out << "slept, a=" << a << endl;
a = 20;
SLEEP(500);
out << "slept, a=" << a << endl;
a = 30;
SLEEP(250);
out << "slept, a=" << a << endl;
a = 40;
SLEEP(100);
out << "slept, a=" << a << endl;
qApp->exit();
}
private:
int a; //used in place of automatic variables
private:
void sleep(int ms, void (Object::*target)()) {
next = target;
timer.start(ms, this);
}
void timerEvent(QTimerEvent * ev)
{
if (ev->timerId() == timer.timerId()) {
timer.stop(); (this->*next)();
}
}
QTimer periodic;
QBasicTimer timer;
void (Object::* next)();
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Object o1;
#ifdef Q_WS_WIN
timeBeginPeriod(1); //timers will be accurate to 1ms
#endif
return a.exec();
}
#include "main.moc"

OriginalL'auteur Kuba Ober

Pour Qt 4.8.0 (la version que j'utilise), QThread::sleep, QThread::msleep et QThread::usleep ont été rendues publiques, de sorte que vous pouvez les appeler directement. Dans les précédentes versions de Qt, ils ont été static protected.

par exemple QThread::sleep(5); //sleep for 5 seconds

OriginalL'auteur Bruce Jia