Discussion :

[Karl Marx]

Bonjour,

Je suis actuellement entrain de réaliser une petite application pour m’entraîner et j'aurais besoin de me servir du système de threading ( c++11 ) pour effectuer cette opération :

- Mon main est appelé suite au lancement du programme et exécute les quelques bricoles qu'il doit faire, ce main contient également une boucle qui attend que l'utilisateur lui retourne une instruction comme par exemple sortir de la boucle pour terminer le programme.
- Avant que la boucle dans le main soit appelée, un thread doit être lancé et ce thread contient lui même une boucle infini et devra le rester tant que l'utilisateur n'aura pas confirmer une commande d’arrêt dans la fameuse boucle du main.

Dans la boucle de mon thread, il n'y a pas de fonction bloquante pour l'instant.

Ma question est donc, comment vous y prendriez-vous pour réaliser ceci ?

Je vois bien une solution plutôt simple à base de "std::thread" mais il faut en même temps que le thread qui exécute le programme en arrière plan sache quand il doit arrêter ses opérations proprement avant que le main soit rendu ( qu'importe ou en est le thread au moment de l’exécution de son programme, il doit pouvoir quitter à tout moment ). Je suppose donc que je dois me servir des mutex et de "std::lock_guard<>" ou "std::unique_lock<>" pour partager l'état entre le main et le second thread sans que le second thread ne puisse modifier l'état retourné par le main ?

J'ai lu cette documentation de 8 pages ( forte intéressante ) : http://www.justsoftwaresolutions.co....g-threads.html mais je dois avouer qu'après sa lecture, tout ça est un peu confus et j'ai encore du mal à comprendre quand utiliser quoi et pourquoi et de quelle manière. ( Mon niveau en Anglais médiocre n'a pas du arranger les choses ).

Si une âme charitable pouvez me remettre sur la piste avec quelques explications, je suis preneur.

Merci par avance pour toute aide apportée.

[white_tentacle]

Je ne suis pas sûr d’avoir très bien compris ton problème, mais en général, lorsqu’on a à la fois un « worker thread » et un thread de contrôle, on utilise un schéma de la forme suivante :

Code :

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

1
2
3
4
5
6
 
while(!stopReceived) {
  do_some_work();
  if(nothingToDoLeft)
     waitForSomethingToDo();
}

Afin de pouvoir interrompre rapidement le thread de traitement, il faut que « do_some_work > ne soit pas long à l’échelle de temps considérée (pour une interruption humaine, par exemple, 100 ms semble raisonnable). Si le traitement est plus long, ça veut dire qu’il faut simplement pouvoir le décomposer et garder un certain état cohérent qu’on pourra reprendre plus tard.

Ensuite, dans le main, tu te contentes d’attendre la commande d’arrêt, et quand elle arrive, tu mets le « stopReceived » à vrai pour le thread. Pour le « waitForSomethingToDo », si tu en as besoin, le mécanisme à utiliser est celui des « condition variable ».

[Karl Marx]

Tout d'abord merci pour ta réponse.

Oki, je vois ce que tu veux dire. Alors moi j'ai eu si on peut dire une autre approche avant que tu ne postes ton message ( mais qui ne fonctionne pas pour le moment ), En gros dans mon main j'ai une variable de type booléen qui récupère la condition dans laquelle doit se trouver le programme, un interrupteur on/off tout simplement ça donne ceci :

Pour mon main :

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
29
30
31
32
33
34
35
int main(int ac, const char* av[])
{
 
    if(ac > 1 && strcmp(av[1], "start") == 0)
    {
 
        bool onOff = true;
 
        std::string command;
 
        std::thread t1(&loopThread, &onOff);
 
 
        do
        {
            std::cin >> command;
            if(command.compare("off") == 0)
            {
                onOff = false;
                t1.join();
 
            }else
            {
                std::cout << "unknow command, please if you want stop it, use 'off' command" << std::endl;
            }
 
        }while(onOff != false);
 
    }else
    {
        std::cout << "unknow command, plz use 'start' command" << std::endl;
    }
 
    return 0;
}

Pour ma fonction appelée dans un thread :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void loopThread(const bool* cond)
{
      sf::Clock clock;
   do
    {
        if(clock.getElapsedTime().asSeconds()>=2)
        {
           std::cout << cond << std::endl;
           clock.restart();
        }
 
    }while(*cond != false);
}

J'essais donc de retourner l'adresse mémoire du boléen dans le main en la renvoyant en paramètre de la fonction dans mon thread pour pouvoir stopper la boucle la bas avant de stopper celle du main. Le problème, c'est que quand je retourne une adresse mémoire en paramètre de fonction dans un thread , ce n'est pas la bonne adresse alors que si je le fais avec une fonction basique sans thread, aucun problème. Je me dis donc que l'OS gère la mémoire différemment entre une fonction simple qui reçois en paramètre une adresse mémoire et une fonction dans un thread.

Bien sur étant novice dans le domaine je dis peut-être une grosse bêtise. Mais voila ou je but actuellement. Maintenant en lisant ton post, me semble t'il que je ne m'y suis pas prit de la bonne manière.

[Karl Marx]

Ha heu enfaîte, j'ai réussi lol, je me suis merder dans la rédaction du code, du coup normal que sa marchait pas. Pardon donc pour mon précédent post et merci toutefois pour tes éclaircissements.

[white_tentacle]

Je pense que le problème que tu as vient du fait que tu fais tes tests sur cond et pas sur *cond.

Normalement, les différents threads d’un même processus partagent leur mémoire : aucune raison que l’adresse de cond que tu donnes ne soit plus la même dans l’autre thread.