Fermeture de l'interface et calculs lourds

Bonjour à tous,

j'ai un problème très simple et pourtant je n'ai trouvé nulle part une solution.
J'ai une fenêtre Qt avec un bouton qui lance une fonction de traitement qui prends plusieurs minutes à s’exécute, le problème est que lorsque je ferme la fenêtre avant la fin du traitement la fonction ne s’arrête pas et le traitement continue en arrière plan, comment faire pour empêcher cela ?
En gros, je voudrais que fermer la fenêtre arrête la totalité de l’exécution du code.
Avez-vous déjà eu ce problème ?

Merci d'avance pour l'aide,
Matthieu

Tu lances ton traitement dans un autre thread peut être ? Si oui il faudra le stopper et attendre qu'il ait terminé avant de quitter.
Dans tous les cas tu dois stopper ton traitement quand tu détectes la fermeture de ta fenêtre (ou de l'appli). Tu peux faire ça dans void QWidget::closeEvent(QCloseEvent * event) (de ta QMainWindow), ou bien en utilisant le signal void QCoreApplication::aboutToQuit() mais comme le dit la doc c'est vraiment au dernier moment que tu vas exécuter ce code là et il n'est pas possible d'avoir une interaction utilisateur.
De manière générale il est préférable de gérer l'arrêt de ton traitement au plus près du code qui le lance, ne serait-ce que pour l'accès à l'objet qui gère le thread par exemple.

Merci de ta réponse et désolé pour cette réponse tardive.

En gros dans mon code j'ai plein de boucle for() qui s’enchaîne quand je clique sur des boutons et donc du coup je dois créer un boolean de fermeture de ma fenêtre et le vérifier dans chaque boucle, c'est un peu "relou" à faire, non ? (mon code est assez conséquent vue que je développe une IA)

Je pensais vraiment que Qt avais une fonction qui aurait permis de kill la totalité du code lancé par une fenêtre (en gros, fermer le processus sans aller dans le gestionnaire de tache) .

Cordialement,
Matthieu

Ps: Mon thread est effectué automatiquement grâce à la fonction QObject::connect() qui relis ma fonction à l'appuis du bouton.

On peut toujours tout tuer, c'est juste qu'en général on préfère terminer proprement (en libérant des ressources, en écrivant dans des fichiers etc). Selon la tâche on peut vouloir enregistrer l'état courant et proposer de la reprendre plus tard.

C'est sûr que selon ton code tester un booléen venant du thread principal est plus ou moins pénible, il faut décider de "paliers" réguliers dans la procédure de calcul où tester le booléen et interrompre les calculs. Pour ça tu peux envisager une petite fonction qui teste la valeur et quitte le thread, pas besoin de copier coller le code du test donc, juste à appeler ta fonction à chaque palier.

Sinon tu dois pouvoir faire ce que tu veux avec void QThread::terminate().

Merci pour ton aide.
J'ai testé ça, mais ça ne fonctionne pas.

Code:

---

1 2 3 4 5

void MainWindow::closeEvent(QCloseEvent *event) { ui->button_start->thread()->terminate(); }

---

Je ne comprends pas pourquoi quelque chose d'aussi simple est aussi dur à faire, j'ai l'impression de louper un truc :pleure:

Bonjour ce que tu fais avec ton code precedent c'est que tu termines le thread principal de ton programme,car le thread de ton bouton donc d'un element de l'UI est le thread d'UI donc le thread principal.
Donc comme solution,il faut que tu conserves un pointeur sur le thread secondaire que tu crees et que tu lances dans ta classe Mainwindow (comme variable membre de Mainwindow) et que tu appelles dans la methode precedente MainWindow::closeEvent la methode terminate de ce pointeur .(m_pthread->terminate(); si tu as mis le pointeur sur le thread secondaire dans m_pthread)

Merci de ta réponse rapide.

Je vois ce que tu veux dire mais je vois pas trop comment le faire :

Code:

---

connect(ui->button_start, SIGNAL(clicked()), this, SLOT(button_start()));

---

Je crois que mon thread c'est ui->button_start->thread() mais je suis pas sur.
Tu pourrais me montrer ce qu'il faut que je mette.

Merci d'avance.

ton connect se trouve ou ? dans la classe Mainwindow ? dans ce cas ta methode button_start cree t' elle un thread secondaire ?
(ce qu elle devrait faire d'ailleurs )
dans ta methode button_start de Mainwindow tu devrais creer ton thread secondaire(qui peut etre par exemple un thread derivant de QThread et dans la methode run de ce thread tu mets tout ton traitement) et recuperer un pointeur dessus que tu mets dans m_pthread et le demarrer avec start
puis dans closeEvent tu appelles m_pthread->terminate();
la methode connect ne cree pas de thread !!!! et comme je t'ai dit ui->button_start->thread() est ton thread principal, pas ton thread secondaire ou tu veux mettre ta tache en arriere plan

Un processus ou programme a un thread principal et des threads secondaires dans lequel tu peux mettre des traitement longs en arriere plan.Si ton programme a une interface graphique (UI) comme avec Qt, le thread principal est aussi le thread de l'interface graphique (c'est le cas de Qt) et tu crees des threads secondaires pour faire des taches en arriere plan

En gros tu es en train de me dire que je n'ai pas de thread ???
Bah pourquoi quand je ferme ma fenêtre la méthode button_start() continue à l'executer ????
Et surtout comment faire pour la fermer ?

Je sais que c'est un détail mais ça m’énerve et ça me prends la tête car quand je programme j'aime quand tout fonctionne exactement comme je le souhaite.
Je comprends pas, j'ai l'impression d’être le seul à avoir ce problème !!!

En même temps c'est logique vue que j'utilise QCoreApplication::processEvents(); dans une fonction sleep() pour reprendre la sur l'interface.

si tu n'as pas creé de thread dans button_start tu es toujours dans le thread principal de ton application....
et si ton traitement est vraiment long tu aurais mieux fait de creer un thread secondaire dans button_start comme je t'ai dit.
cela necessite aussi de creer une classe de thread derivant de Qthread. (ici on peut utiliser cette maniere pour faire le thread car il y a deux methodes pour faire des threads dans Qt)

En gros, es-ce que cette ligne de code crée un thread ???

Code:

---

connect(ui->button_start, SIGNAL(clicked()), this, SLOT(button_start()));

---

Et si non, pourquoi quand je ferme ma fenêtre ça coupe pas l'exécution de ma méthode button_start() ???

Putain mais c'est pas compliqué ce que je demande, si ?

J'ai l'impression de devenir fou !!! :cfou:

En faite vous devez me trouver trop chiant à chipoté sur un truc comme ça :mrgreen:
Car c'est vrai qu'à part ça mon programme fonctionne très bien et que là pour fermer mon programme j'ai juste qu'à cliqué sur le carré rouge sous Qt.

non connect ne cree pas de thread, mais relie juste un signal à un slot.
regardes la doc de qt sur qt.io à QObject::connect
si tu veux creer un thread tu cree par exemple une classe de thread derivant de Qthread et tu cree un thread dans ta methode button_start et tu le demarre aussi dedans et tu gardes un pointeur dessus pour le terminer (cf messages precedents)

Merci, mais je veux pas un thread je veux juste pouvoir fermer tout mon programme juste en cliquant sur la croix.

mettre ton traitement long dans un thread secondaire comme evoqué plus haut resoudrait surement ton probleme....

Ouais c'est surement ce que je vais faire, merci ;)
Par contre ça prendra plus de ressource non ?
Et je trouve ça très bizarre que Qt n'ait pas prévue quelque chose pour ce cas là, car ça doit être fréquent comme problème, non ?

En tout cas merci pour ton aide.

Tu vas deporter ton traitement long dans un thread secondaire c'est tout.cela ne prend pas beaucoup plus de memoire à priori.et ca ne bloquera plus ton UI.
quand tu as des traitements longs comme celà avec tous les environnements et/ou librairies il faut utiliser des threads secondaires, pas seulement avec Qt.

Je viens de remarquer que quand je ferme ma fenêtre et que j'ai cliqué sur mon bouton, la méthode MainWindow::closeEvent() n'est pas appeler, c'est trop bizarre !!!

Citation:

---

Envoyé par Matthieu76

Par contre ça prendra plus de ressource non ?
Et je trouve ça très bizarre que Qt n'ait pas prévue quelque chose pour ce cas là, car ça doit être fréquent comme problème, non ?

---

Oui, ça prendra un peu plus de ressources que de laisser l'interface geler — par contre, c'est vite compensé par la lourdeur du code qui vérifie si la fenêtre est fermée ou non dans ton code de calcul. L'impact sera négligeable (tant que tu ne crées pas un grand nombre de fils, s'entend.)

Et Qt a bien prévu un mécanisme pour ces cas-là, un mécanisme très général, celui que Stéphane te propose : utiliser un autre fil d'exécution.

Finalement j'ai juste fait un taskkill dans mon destructeur de fenêtre :

Code:

---

System("taskkill /F /IM nom_du_programme.exe");

---

Et le plus frustrant c'est que ça marche très bien.