QThread, moveToThread et emit

Version imprimable

bonjour,
je m'inspire de l'article: https://mayaposch.wordpress.com/?s=qthread pour écrire une application qui threade.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); connect(ui->pushButton_quitter, SIGNAL(clicked(bool)), qApp, SLOT(quit())); connect(ui->pushButton_startThread, SIGNAL(clicked(bool)), this, SLOT(start_thread())); connect(ui->pushButton_stopThread, SIGNAL(clicked(bool)), this, SLOT(stop_thread())); pourVoir = new PourVoir; connect(this, SIGNAL(pour_voir()), pourVoir, SLOT(voir())); emit pour_voir(); }
Dans ce code, le signal pour_voir est bien émis puisque le slot voir() est exécuté (un simple cout).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 //gestion du clic bouton start_thread void MainWindow::start_thread() { thread = new QThread; worker = new Worker(3); worker->moveToThread(thread); connect(thread, SIGNAL(started()), worker, SLOT(process())); //démarre la fonction de thread connect(worker, SIGNAL(finished()), thread, SLOT(quit())); //qd le worker s'arrête, le thread s'arrête connect(this, SIGNAL(stop_worker()), worker, SLOT(fin())); thread->start(); } //gestion du clic bouton stop_thread void MainWindow::stop_thread() { std::cout << "Stop thread demande" << std::endl; emit stop_worker(); }
Dans ce code, start_thread() est appelée et le slot process() tourne bien dans sa boucle infinie.
Mon problème: quand je clic sur stop_thread, je demande l'émission du signal stop_worker mais je ne rentre jamais dans le slot fin() du worker (où j'ai mis un cout) qui ne s'arrête donc jamais.
Je ne vois pas bien la différence entre l'utilisation des deux emit() si ce n'est que les signaux ne sont pas envoyés vers des objets de même type.

SI quelqu'un a une piste...
Merci.

J'ai oublié de poster la classe Worker:

Code:

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
37
38
39
40
41
42
43
44
45
46
 
#include <QObject>
 
class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = 0);
    Worker(int);
    ~Worker();
 
signals:
    void finished();
 
public slots:
    void process();
    void fin();
 
private:
    int loop;
    bool run_process;
};
 
Worker::Worker(int nb) : loop(nb)
{
   run_process = true;
}
 
void Worker::process()
{
    int i = 0;
    while(run_process == true)
    {
        ++i;
        std::cout << i << " - process" << std::endl;
        sleep(1);
    }
    std::cout << "End worker" << std::endl;
    emit finished();
}
 
void Worker::fin()
{
    std::cout << "Worker fin" << std::endl;
    run_process = false;
}

17/12/2020, 08h32
rdtech

Bonjour,
je ressors cette discussion car je m'en suis sorti à l'époque par la simple utilisation d'un QThread.
J'ai bien lu un peu partout que ce n'était pas la meilleure façon de faire et là comme j'ai un peu de temps...
Donc je n'arrive toujours pas à faire fonctionner ce que j'ai écrit.

Le fait d'exécuter le worker dans un thread le rend-t-il insensible a à un signal venant de la MainWindow?

Merci.
17/12/2020, 16h47
rdtech

Bonjour,
je me répond à moi-même pour le moment.
J'y ai passé du temps ce matin, sans résultats et la seule différence que je note entre les exemples proposés sur le web et ce que je fais, c'est que c'est depuis la MainWindow que j'émet un signal en direction du Worker qui tourne dans une boucle infinie jusqu'à réception de ce signal.
Est-ce la source du pb? Mon worker qui est un QObject et tourne dans un QThread n'est-il plus sensible aux signaux provenant du thread principal?

Merci...