Discussion :

[med365]

Bonjour

Voila mon problème, j'ai une classe représentant un objet de type hash qui contient les méthodes md5, sha1...sha512.
Ces méthodes créent des objets de type thread_algo (thread_md5, thread_sha1...) qui lorsqu'ils sont appelés calculent le hash d'une chaine passée en paramètre avant d'en retourner la valeur dans une variable récupérée ensuite par la méthode de l'objet hash qui la retourne.

Ma question est la suivante :

Dans mon programme principal, puis-je créer un objet hash et en appeler successivement les méthodes de calcul sans problème ? ou cela va-t-il poser problème (execution non simultanée ou des trucs du genre).

Ca donnerai quelque chose du genre :

Code :

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

1
2
3
4
5
a = hash(string_to_hash)
a.md5()
a.sha1()
a.sha224()
....

Avec l'objet hash (incomplet) :

Code :

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

1
2
3
4
5
 
class hash():
    def md5(self):
        threadmd5 = thread_md5(self.target) # en admetant que self.target soit déclarer dans la fonction __init__
return threadmd5.result()

Et l'objet thread_md5 :

Code :

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

1
2
3
4
5
6
7
8
9
 
class thread_md5(threading.Thread):
    def __init__(self, target):
        threading.Thread.__init__(self)
        self.target = target
    def run(self):
        self.result = hashlib.md5(self.target).hexdigest()
    def result(self):
        return self.result

Autre question : Ne vais-je pas utiliser beaucoup trop de mémoire en transmettant la chaine target d'objet en objet en en créant une copie propre à chaque thread etc... ? Comme ca doit pouvoir être rapide sur de gros fichiers ca me préoccupe.

Merci de votre aide.
Au revoir

[oiffrig]

En ce qui concerne la première question, à mon avis ça ne devrait pas poser problème
Pour ce qui est de la mémoire, le passage se fait par référence, donc pas de problème, sauf si tu copies la chaîne.

[tyrtamos]

Bonjour,

Pour la chaîne à coder, fais en sorte de la stocker par le __init__ de la classe hash sous forme de self.target. Elle sera alors à disposition des méthodes de la classe comme une variable "globale" de la classe.

Quand la méthode md5() est appelée par a.md5(), il ne suffit pas d'instancier la classe thread_md5 pour lancer le thread. Il faut utiliser après threadmd5.start(), ce qui lancera la méthode run() du thread, et c'est cette méthode qui s'exécutera en tâche de fond.

Après, il faut savoir quand run() aura fini de calculer, parce que tant qu'il n'a pas fini, il ne faut surtout pas essayer de récupérer le résultat. Tu peux utiliser l'une de ces 2 solutions:

- threadmd5.join() bloquera le code jusqu'à la fin d'exécution du thread. Ce qui n'empêchera pas les autres threads de fonctionner s'ils ont été lancés avant: cela veut dire que tu peux lancer tous les threads en même temps, et attendre avec tous les join() qu'ils aient tous terminé.

- faire une boucle while en testant threadmd5.isAlive( ). C'est seulement quand le thread sera mort que le résultat sera disponible. Cette méthode permet de faire autre chose dans la boucle en attendant.

Tyrtamos

[med365]

Salut

Donc j'ai quand même besoin de join(), d'ailleurs c'était évident merci !

Pour la chaine, justement je doute, elle est utilisée à chaque fois comme variable globale de la classe sauf que je crois que je copie dans les méthodes threads appelées par les méthodes des différentes classes, c'est pas très clair mais je vais faire en sorte d'utiliser uniquement des références.

Je vais regarder tout ça et vous donne des nouvelles, merci de votre aide

Edit : En fait voila la source : http://www.miraclesalad.com/webtools/clip.php?clip=19a2
Le truc c'est qu'en fait, dans le programme principal je compte instancier un objet hash et appeler successivement ses différentes fonctions md5, sha1... ce qui fait que la gestion des threads est un peu masquée...

Si je fais ça, c'est bon ? Qu'en est-il de l'occupation mémoire ? Je sens que je vais réécrire tout ça

Edit 2 : Je ne peux pas utiliser une méthode run() avec tous les threads.start() puis .join() car je veux laisser le choix à l'utilisateur des algorithmes à utiliser

[med365]

Et bien personne n'a d'idée ?
j'ai pensé à instancier l'objet avec comme argument un tuple des algos à calculer, ensuite une premiere boucle for pour lancer les threads puis une deuxième pour faire les .join() cependant je trouve ça moche niveau code, personne n'a une meilleure idée ?

Voila une idée du code :

Code :

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

1
2
3
4
5
6
7
8
 
def __init__(self, liste_algos):
        self.liste_algos = liste_algos
def calc(self):
        for i in self.liste_algos:
                i.start()
        for i in self.liste_algos:
                i.join()

Autre chose, la boucle ne risque pas de se stopper une fois le premier join() fait ?

[tyrtamos]

Bonjour,

Voilà ce que je ferais à ta place:

- abandonner la classe hash et créer les différentes fonctions pour les différents algorithmes.

- faire en sorte que l'utilisateur choisisse l'algorithme souhaité

- créer une classe thread "Calcul" qui se charge du calcul avec n'importe quel algorithme, et lui passer la fonction choisie à son instanciation.

- cette logique est valable que le programme soit en console ou avec un programme graphique.

Voilà ce que ça donnerait comme code (tel qu'il est, tu peux le copier-coller et l'essayer):

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#!/usr/bin/python
# -*- coding: latin1 -*-
from __future__ import division
 
import threading
 
# ...
 
def md5(x):
    # calcul du md5 de x
    # ...
    return x
 
def sha1(x):
    #...
    return x
 
# ...
 
class Calcul(threading.Thread):
 
    def __init__(self,fnhash,expr):
        threading.Thread.__init__(self)
        self.fnhash=fnhash
        self.expr=expr
        self.result=None
 
    def run(self):
        self.result=self.fnhash(self.expr)
 
    def resultat(self):
        return self.result
 
#################################################################
if __name__ == "__main__":
 
    # choix par l'utilisateur de la fonction à utiliser
    # ...
 
    # lancement du calcul avec le choix = md5 appliqué à la valeur x=5 pour l'exemple
    x=5
    calcul=Calcul(md5, x)
    calcul.start()
    calcul.join()
    r=calcul.resultat()
 
    # restitution du résultat à l'utilisateur
    print r

Tyrtamos

[med365]

Merci, je viens de regarder ton code et ça à l'air très bien mais en fait j'aimerai pouvoir lancer plusieurs calculs en parallèle et non un seul, merci pour l'idée mais me reste le problème de la liste d'arguments

[tyrtamos]

Dans ce cas, tu peux instancier autant de fois que tu veux le même thread Calcul avec à chaque fois le nom de la fonction hash choisie. Et tu pourrais même afficher les résultats au fur et à mesure que chaque thread a terminé.

Tyrtamos

[med365]

Oui c'est sur, d'ailleurs ce sera mieux Et puis utiliser des fonctions hors classes me permet de donner la possibilité à l'utilisateur de désactiver le multithreading (en cas de pb sur un viel ordi par exemple).

merci de votre aide, je test et je fait un feedback