Discussion :

[le-roy_a]

Bonjour,

je cherche a faire une fonction qui boucle jusqu'a la modification d'une variable ex :

Code :

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

1
2
3
4
5
6
 
 
while (myVar != 4)
{
 // fait plein de chose.
}

le probleme c'est que meme executer dans un thread ce genre de boucle occupe 100% du cpu (d'ailleurs ce ne me choque pas) mais comment feriez pour faire ce genre de chose. En fait qu'elle est la meilleur technique pour attendre une modification de variable ?

ps : en rajoutant un sleep(1) à l'intérieur de la boucle while la charge cpu tombe.

[r0d]

Bonjour,

à mon avis, le plus propre est d'avoir une classe qui gère ton thread (qui le lance , qui communique avec lui, et qui fourni une interface pour que les autres classes puissent l'utiliser proprement).

Ainsi, tu aurais un code qui pourrait ressembler à ceci:

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
ThreadManager myThread; //classe qui gère le thread
myThread.LaunchThread();
while (myThead.Continue())
{
// ton code ici
}
 
// avec un truc du style:
bool ThreadManager::Continue(const unsigned int delay) const
{
    if (mavariable!=4)
    {
        Sleep(delay);
        return false;
    }
    else
        return true;
}

Le sleep est indispensable, mais je crois qu'il y a des risques au niveau portabilité.

[le-roy_a]

ok merci donc le sleep est obligatoire pour empecher l'usage a 100 % du cpu ?

si oui quelqu'un sait il pourquoi ?

[Ksempac]

Parceque l'instruction sleep signifie "Lache le CPU pour X ms"

Plus précisement :
Ton CPU fait du multi taches...Donc il regarde quels sont les processus qui ont besoin de travailler et il attribue un certain quota de temps a chaque processus qui en a besoin, en fonction d'un certain nombre de regles de priorité.

Lorsque tu fais un while(1){} ton processus a toujours quelquechose a faire (boucler), donc il est en permanence en train de demander le CPU. Donc le CPU va lui accorder du temps, et comme la plupart des autres processus n'ont que des petites taches a faire qui prennent tres peu de temps, c'est ton while(1) qui bouffe tout le reste du temps CPU.

La fonction sleep oblige le programme a laché le CPU pour un certain temps. Il laisse donc les ressources libres durant ce temps.

[Charlemagne]

Y'a des routines qui sont prévues pour qu'un thread attende jusqu'à ce qu'une condition soit respectée (pthread) ou qu'un évènement se produise (windows).

Voici l'exemple de la doc pthread

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
Consider two shared variables x and y, protected by the mutex mut, and a condition variable cond that is to be signaled whenever x becomes greater than y.
 
int x,y;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
 
    Waiting until x is greater than y is performed as follows: 
 
pthread_mutex_lock(&mut);
while (x <= y) {
        pthread_cond_wait(&cond, &mut);
}
/* operate on x and y */
pthread_mutex_unlock(&mut);
 
    Modifications on x and y that may cause x to become greater than y should signal the condition if needed: 
 
pthread_mutex_lock(&mut);
/* modify x and y */
if (x > y) pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mut);

[le-roy_a]

ok ,

donc la métode entre guillemet pour attendre un changement serait du style

Code :

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

1
2
3
4
5
6
 
while(1)
{
  // mon code
 sleep(1);
}

ps : Desole j'avais pas vu la version de charlemagne mais est t'elle portable

[Charlemagne]

Chaque bibliothèque de multi-threading a sa propre syntaxe, donc en ce sens c'est pas portable, à moins de faire des appels différents selon les systèmes avec des #ifdef.

Pthreads est la bibliothèque par défaut sous Unix/Linux/Cygwin, mais il existe quand même une version pthread sous windows, ce qui fait que pthreads est la bibliothèque de choix pour la portabilité.
http://sourceware.org/pthreads-win32/

Il est en outre toujours possible d'utiliser une bibliothèque qui encapsule ces appels.

[le-roy_a]

Juste pour info la librairie QT propose une classe de thread portable.

[Charlemagne]

QT est une des bibliothèques portable. Je connais pas vraiment celle-ci. J'imagine que comme les autres, elle encapsule les fonctions du système.
Y'a aussi:
-Boost (très bof bof)
-Intel TBB (de très loin ma préférée, mais payante)