Discussion :

[marocleverness]

Bonjour

J'ai lu dans mon cours qu'il y a deux formes d'attentes pour un thread une actif et l'autre est dite passif.
j'ai pas bien compris qu'est ce que ça veut dire!

Merci d'avance pour vos eclaircissements.

[mavina]

salut,

je pense que ton cours fait référence aux 2 fonctions
- sleep(int n) qui "endort" le thread pendant n milli secondes
- yield() qui "endort" le thread pour laisser les autres threads s'executer

sleep est à mon avis une attente passive et yield active

mavina, qui espere ne pas trop être dans la semoule ^^

[Baptiste Wicht]

Moi je dirais que c'est employé seulement quand 2 threads sont "concurrents", c'est à dire qu'ils employent la même ressource et que leur opération sur cette ressource est critique (c'est à dire ne peut être interrompue). Ainsi tu as deux méthodes de faire pour éviter que les threads ne se marchent dessus :

1. Attente active : Il me semble que c'est quand tu boucles dans le vide en attendant sur une condition que l'autre thread renvoie, le problème c'est que ca bouffe des performances
2. Attente passive :Ca consiste à faire dormir ton thread (sleep()) pendant un certain temps, mais le problème c'est que tu ne peut pas être sur du temps qu'il faut le laisser "dormir"

Je suis pas sur non plus que c'est ca

[lunart]

Et hop un troisième avis:
J'ai eu un projet de simulation de robots à faire récemment.
Les robots étant en threads.
J'ai utilisé 2 sortes d'attentes:
- sleep() permet d'endormir le processus un certain temps (que je qualifierais d'attente active) permet d'éviter de faire tourner le processeur dans le vide par exemple.
- wait() interomp le processus du robot (que je qualifierais d'attente passive) il attend qu'un autre thread lui dise de redémarrer à l'aide de la fonction notify() ou notifyAll(). Dans mon cas seul le processus qui a lancé le thread à l'aide de start() pouvait execute la commande notify() ou notifyAll()

[Satch]

Je dirai aussi qu'il s'agit de sleep et wait.

Mais je qualifierai plutôt sleep de passif (ben oui, il ne fait rien et attend bêtement que le temps passe) et wait d'actif(s'il est notifié il se réveillera, il reste donc actif dans le sens ou il attend d'être notifié)

mais je peux me tromper

[®om]

C'est vrai que pour un Thread, c'est assez ambigüe comme vocabulaire l'attente active et passive, et je pense que ce n'est pas très pertinent à la compréhension d'un Thread...

[adiGuba]

Salut,

- sleep() permet d'endormir le processus un certain temps (que je qualifierais d'attente active) permet d'éviter de faire tourner le processeur dans le vide par exemple.

Non justement : sleep() est une méthode d'attente passive... tout comme wait() ou yield() (même si ce n'est pas vraiment une "attente", yield laisse seulement la main aux autres threads)

Plus globalement l'attente passive signifie que ton thread ne fait rien pendant son attente : le thread est endormie. Il n'utilise pas de temps processus tant qu'il est en attente...

Par exemple si tu endors ton thread pendant 10s de la manière suivante c'est une attente passive (ton thread ne fera rien pendant 10s) :

Code :

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

Thread.sleep(10000);

Au contraire on parle d'attente active lorsque le thread effecute un traitement pour savoir si il doit continuer ou pas. Ce type d'attente peut être assez lourde en temps processus, car elle effectue un grand nombre de fois le même traitement... Elle prend donc du temps processus pour "attendre"...

Ainsi pour "endormir" ton thread pendant 10s avec une attente active cela donnerait :

Code :

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

1
2
long t0 = System.currentTimeMillis();
while ( System.currentTimeMillis()-t0 < 10000) ;

Ce qui chez moi me donne plus de 120 millions d'itérations (et donc 120 millions d'appels à System.currentTimeMillis(), 120 millions de soustractions, et 120 millions de comparaison...)


Globalement, les attentes actives pures sont à éviter car elles pourrisent les performances en demandant au processeur d'effectuer la même opération un grand nombre de fois...

Si on ne peut pas faire autrement, il est préférable d'y ajouter une attente passive à l'intérieur afin de limiter le nombre d'instruction...

Ainsi en rajoutant un yield() on descent à 8 millions d'itérations :

Code :

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

1
2
3
4
long t0 = System.currentTimeMillis();
while ( System.currentTimeMillis()-t0 < 10000) {
    Thread.yield();
}

Et encore mieux avec un sleep de 5ms, on se retrouve avec un peu plus de 1600 itérations :

Code :

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

1
2
3
4
long t0 = System.currentTimeMillis();
 while ( System.currentTimeMillis()-t0 < 10000) {
    Thread.sleep(5);
}

Donc pour résumer :

• Attente passive : le thread ne fait rien, et n'utilise le processeur.
• Attente active : le thread effectue des traitements pendant toute la durée de l'attente. Il utilise donc le processeur.

Les attentes actives doivent obligatoirement être cumulé avec une attente passive afin d'éviter de plomber les performances

a++

[tchize_]

je rejouterais que, en général, les attente active ne sont nécessaires qu'à bas niveau, dans l'os, quand il est mpossible de mettre en suspend, pour une raison ou une autre, le thread courant en attendant une condition. A au niveau, avec les système de sémaphore et de notification, les sleeps, etc, il est vraiment rare d'avoir besoin d'une attente active. Sauf bien sur si tu veux effectuer un traitement quelconque "en attendant", du style "tant que j'ai pas la main sur la ressource X, je fais du précalcul dont j'aurais besoin du résultat plus tard"