Discussion :

[Matthieu76]

Bonjour,
j'ai un petit problème très simple à comprendre mais assez complexe à résoudre.

Voici le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void MainWindow::sleep(int time)
{
    dieTime = QTime::currentTime().addMSecs(time);
    while (QTime::currentTime() < dieTime)
        QCoreApplication::processEvents(); // (QEventLoop::AllEvents, 100)
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void MainWindow::button_test1()
{
    while(true)
    {
        this->write("test 1", "console");
        this->sleep(1000);
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void MainWindow::button_test2()
{
    int nb = 0;
    while(nb < 10)
    {
        this->write("test 2", "console");
        this->sleep(1000);
        nb++;
    }
}

Quand j'appuis sur le bouton test2 après le bouton test1, le bouton test1 se stop, le bouton test2 écrit 10 fois "test 2" et seulement à la fin le bouton test1 reprends l'écriture de "test 1" dans la console de mon application.

N'y a-t'il pas un moyen pour que button_test1 et button_test2 s’exécute en même temps en prenant le relais durant le sleep ?

La seul solution est-elle de passer par des threads ???

Merci d'avance,
Matthieu

[dalfab]

Bonjour,

Par définition les actions se déroulent sur the thread gérant l'UI. Etant sur le même thread ils sont forcements successifs.
Dans ce cas 'simple' avec des délais d'attente, il est possible de permettre un parallélisme en découpant le traitement (le plus natarel serait d'utiliser des timers).
Si par contre les délais représentent des véritables actions que tu souhaites en parallèle, là comme il s'agit d'avoir du CPU en parallèle ; une seule possibilité les threads.

[Matthieu76]

Justement, c'est pas ce qui est déjà fait dans la fonction sleep ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QCoreApplication::processEvents();

Cette instruction permet déjà de redonner la main à l'UI ce que me permet d'apuyer sur le 2e bouton.

Si je comprends bien, durant ce sleep je dois redonner la main aux fonctions en cours d'exécution (ici button_test1) ?
En faite je croyais que mon sleep le fessait déjà.

Il n'y a pas de moyen simple de faire ça juste en rajoutant quelque chose dans le while de mon sleep ???

[Matthieu76]

Oui, il s'agit d'une véritable pause.
Tu peux me montrer comment utiliser un timer dans ma fonction sleep() stp ?

[dalfab]

La fonction pause suspend le thread et donne la main aux autres threads. Ici les deux actions utilisant le même ne peuvent que s'exécuter une après l'autre.
Je ne connais pas du tout Qt, je prends juste un exemple Qt que j'essaie d'adapter (et j'ai supposé que MainWinddow n'est instanciée qu'une fois d'où des QTimer et une variable n en static)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
void MainWindow::button_test1() {
    static QTimer *timer1 = 0;
    if ( timer1 == 0 ) {
        timer1 = new QTimer( this );
        connect( timer1, SIGNAL(timeout()), this, SLOT(test1_cyclique()) );
    }
    timer1->start( 1000 );
}
void MainWindow::test1_cyclique() {
    this->write( "test 1", "console" );
}
static QTimer *timer2 = 0;
void MainWindow::button_test2() {
    if ( timer2 == 0 ) {
        timer2 = new QTimer( this );
        connect( timer2, SIGNAL(timeout()), this, SLOT(test2_cyclique()) );
    }
    if ( !timer2->isActive() )
        timer2->start( 1000 );
}
void MainWindow::test2_cyclique() {
    static int n = 10;
    this->write( "test 2", "console" );
    if ( --n == 0 ) {
        n = 10;
        timer2->stop(); // terminer apres 10 messages
    }
}

[Matthieu76]

Merci de ta réponse mais ça ne peut pas fonctionner car dans mon vrai code j'ai :


// une instruction

sleep(une durée définie);

// une autre instruction

sleep(une durée définie);

// encore une instruction

sleep(une durée définie);
.
.
.
.
etc.

Et je voudrais que pendant le temps des sleep je puisse continuer à exécuter d'autre choses.