Discussion :

[guillaume07]

Salut,

Quel est l'avantage d'utilisre un boost::timer dans un thread plutôt que la combo sleep+while 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
14
15
16
17
18
19
20
21
 
void print(const boost::system::error_code& /*e*/,boost::asio::deadline_timer* t,int* count)
{
  if (*count < 5)
  {
    std::cout << *count << "\n";
    ++(*count);
    t->expires_at(t->expires_at() + boost::posix_time::seconds(5));
    t->async_wait(boost::bind(print, boost::asio::placeholders::error, t, count));
  }
}
 
 
int main(int argc, char *argv[])
{ 
    int count = 0;
    boost::asio::io_service io;
    boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
    t.async_wait(boost::bind(print,boost::asio::placeholders::error, &t, &count));
    boost::thread(boost::bind(&boost::asio::io_service::run,&io));
}

[NoIdea]

Je pense aucun. A moins que boost utilise les timer système ?
Sa évite quand même d'écrire soi même la fonction de thread.

[guillaume07]

oui mais écrire soit même la fonction de thrad revient à faire :

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
void print( )
{
 int i = 0;
  while(i<5)
  {
    std::cout << i << "\n";
    ++i;
    sleep(5000); //ou équivalent boost
  }
}
 
 
int main(int argc, char *argv[])
{    
    boost::thread( boost::bind(print) );
}

[Joel F]

euh sleep c'est de l'attente active, c'est genre infame

[guillaume07]

comment est ce qu'une attente inactive est gérée, je connaissais pas du tout cette notion?

[zeldomar]

euh sleep c'est de l'attente active, c'est genre infame

Par active, tu entend que du cpu est consommé ?

Il me semblait qu'un thread "endormi" ne consommait pas de cpu.

[Joel F]

sleep n'endort pas le thread non ?

[Firwen]

(m)/(u) sleep, dans le version POSIX du moins, n'est pas de l'attente active non. Il relache le proco.

[guillaume07]

j'acquiesse

[Mat.M]

sleep n'endort pas le thread non ?

c'est exact ; l'exécution du thread courant est suspendue

[Joel F]

OK

[guillaume07]

ma question demeure

[Astraya]

La question judicieuse serais de ce demander pourquoi on veux faire attendre un thread un temps X à chaque fois! Si c'est pour une question de synchro... beurk

[guillaume07]

par exemple pour recharger une donnée provenant d'une BDD toutes les 10 secondes

[gl]

Quel est l'avantage d'utilisre un boost::timer dans un thread plutôt que la combo sleep+while dans un thread

• sleep() est Posix et à ce titre pas forcément présent (de mémoire sous Windows il existe _sleep() et Sleep() mais pas sleep()), boost_timer fourni la couche d'abstraction.
• Les timers boost ont une résolution meilleure que la seconde.

[guillaume07]

parfait merci

[Matthieu Brucher]

Et si tu veux déclencher des fonctions, avec Boost, tu n'as qu'une seule boucle qui se charge de tout, tu n'es pas obligé d'avoir un thread pour chaque timer.

Autre détail, tu déclenches un timer pour dans 5s avec Boost, tu travailles un bout de temps (genre 1s +/- 10%), ton prochain déclenchement sera dans 5s, pas dans 6s +/- 10%.

[3DArchi]

Bonjour,
J'ai tendance à partager le réflexe premier de Joel pour dire qu'un while + sleep est une attente active même si le thread appelant sleep passe dans un état non schedulable.
J'ai une approche extensive du 'actif' : le thread reste bloqué dans une attente alors qu'il pourrait être sollicité pour d'autres tâches pendant que celle ci attend gentiment son timer. Cette vision vient probablement des tâches en embarqué qui s'articulent sur une boucle de type :

Code :

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

1
2
3
4
tant que (1)
      Lecture bloquante Evenement (timer parmi les évènements ou sortie sur timer)
      Dispatch évènement
fin tant que.

Si un des objets gérant un évènement se met dans un while+sleep, alors on ne rentre plus dans la boucle de la tâche. D'autres évènements peuvent s'accumuler dans la file voir être perdus.
D'où, un while+sleep ~ attente active => à éviter.

[zeldomar]

Et si tu veux déclencher des fonctions, avec Boost, tu n'as qu'une seule boucle qui se charge de tout, tu n'es pas obligé d'avoir un thread pour chaque timer.

Autre détail, tu déclenches un timer pour dans 5s avec Boost, tu travailles un bout de temps (genre 1s +/- 10%), ton prochain déclenchement sera dans 5s, pas dans 6s +/- 10%.

Bonjour Matthieu,

L'avantage que tu cite me semble très intéressant.
Qu'entend par "une seule boucle" ? un seul thread ?

Par rapport à ta deuxième partie, sais-tu comment cela est gérer ?

Merci