Threads retournant valeur

Version imprimable

27/02/2008, 17h03
med365

Threads retournant valeur

Bonjour

J'ai besoin de récupérer la valeur de retour de la fonction qu'un thread execute.
En fait je voudrais calculer les hash md5, sha1 etc... d'un fichier pour cela je charge le fichier dans une variable ensuite je voudrais que chaque hash soit calculé par un thread séparé et que lorsque le calcul est fini récupérer la valeur de sortie dans une variable (donc le hash calculé) et l'afficher.

Je débute avec les threads, j'ai vu quelques choses comme les thread locks, est-ce que ca peut m'aider ?
27/02/2008, 18h17
tyrtamos

Bonjour,

Si tu créés chaque thread avec une classe (et avec le module threading), tu créés une variable appartenant à la classe (self.toto). C'est cette variable qui recevra le résultat quand il sera disponible. Idem pour les autres threads de calcul.

Tu créés ensuite une méthode au sein de la classe (différente de run()), permettant de renvoyer le résultat quand il est obtenu.

A partir du programme principal, le problème va donc, une fois les calculs lancés dans les threads, de détecter qu'ils sont terminés, et que donc le résultat est disponible. On peut faire cela avec join(), ce qui fait que le programme principal ne fera rien en attendant, mais on aussi faire cela avec une boucle qui teste si le thread est encore actif: isAlive(). A chaque fois qu'un thread est terminé, tu peux récupérer le résultat, et quand ils sont tous terminé, c'est fini.
27/02/2008, 19h15
med365

Merci pour ces explications mais si ce n'est pas trop te demander, j'avoue q'un exemple en python me permettrait de mieux saisir le principe :)

A+

Voilà un programme de principe (relis mon message précédent pour l'explication):

Code:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import threading
 
##################################################################
# thread1
#
class Calcul1(threading.Thread):
 
    def __init__(self,param1,param2):
        threading.Thread.__init__(self)
        self.param1=param1
        self.param2=param2
        # initialisation de la variable qui portera le résultat
        self.result=None
 
    def run(self):
        """Lance le calcul en tâche de fond et stocke le résultat"""
        .....
        .....
        .....
        self.result=le résultat du calcul
 
    def result(self):
        """Renvoie le résultat lorsqu'il est connu"""
        return self.result
 
##################################################################
# idem thread2 avec class Calcul2
 
##################################################################
# idem thread3 avec class Calcul3
 
##################################################################
# programme principal
 
.....
 
# initialisation des threads
s1=Calcul1(param1,param2)
s2=Calcul2(param1,param2)
s3=Calcul3(param1,param2)
 
# lancement des threads
s1.start()
s2.start()
s3.start()
 
 
 
# 1ère solution d'attente avec join():
s1.join()
s2.join()
s3.join()
 
 
# 2ème solution d'attente avec isAlive():
while s1.isAlive() or s2.isAlive() or s3.isAlive():
    # ici, on peut faire autre chose en attendant!
    ......
    ......
    # et compléter par une tempo genre "time.sleep(0.2)" pour laisser la priorité aux calculs
 
# récup des résultats:
resultat1=s1.result()
resultat2=s2.result()
resultat3=s3.result()
 
.....
 
# Suite du programme principal

27/02/2008, 20h46
med365

Super merci :)