Problème Multi thread Python 3.2

Bonjour

Je suis en train de développer un programme qui ping dynamiquement n machine.
Or le temps d’exécution de celui ci est long.
Donc pour optimiser cela, je me suis interrogée au multi thread.
Le problème est que je ne sais pas comment on peut l'utiliser dans ce cas de figure, je voudrais exécuter les ping plus rapidement, en background si il faut, puisque il y a un affichage de fenêtre juste après.

j'ai utiliser une fonction f(self, tempo=2.0)

threading.Timer(tempo,self.f).start
appel de la fonction qui ping toute les adresses

mais rien y fait.

Avez vous une solution à ce problème ?

Merci d'avance

Le code ! Le code ! Le code ! :evil:

Franchement, je ne vois pas comment t’aider sérieusement avec ce seul vague pseudo-code…

Le code de la fonction pingAdr(adresse) que j'appelle dans le main dans un for pour executer toute ma liste d'adresse IP a pingé.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def pingAdr(adresse):
   os.chdir('c:\\')
   a = os.popen('ping '+adresse+' -n 1 -w 500')
   chaine=a.read()
   a.close()
   if chaine.find('TTL')>1:
   return(adresse+' :
   '+chaine[chaine.find('temps')+5:chaine.find('TTL')-1])
   else:
    return(adresse+' : pas de reponse')
 
def pingAllAdr()
   for adr in listeIP:
        pingAdr(adr)

Ok, alors voici ce que je propose (sous python 3.2):

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
from concurrent.futures import ThreadPoolExecutor
import subprocess
 
def pingAdr(adresse):
    # Je suis sous linux, donc j’ai commenté ça…
#    os.chdir('c:\\')
    # Je remplace le vieux os.popen par le nouveau module subprocess…
#    a = os.popen('ping '+adresse+' -n 1 -w 500')
#    chaine=a.read()
#    a.close()
    ping_proc = subprocess.Popen(['ping', '-n 1', '-w 500 ', adresse], universal_newlines=True,
                                 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    chaine = ping_proc.stdout.read()
    ping_proc.wait() # Just in case…
    if chaine.find('TTL')>1:
        return(adresse+' : '+chaine[chaine.find('temps')+5:chaine.find('TTL')-1])
    else:
       return(adresse+' : pas de reponse')
 
# Une liste d’IP de test…
listeIP = ['192.168.0.1', '192.168.0.2', '192.168.0.3', '192.168.0.4', '192.168.0.5',
           '192.168.0.6', '192.168.0.7', '192.168.0.8', '192.168.0.9', '192.168.0.10',
           '192.168.0.11', '192.168.0.12', '192.168.0.13', '192.168.0.14', '192.168.0.15',
           '192.168.0.16', '192.168.0.17', '192.168.0.18', '192.168.0.19', '192.168.0.20']
 
# Le super-simple à utiliser ThreadPoolExecutor de concurrent.futures
# (ici, avec au maximum 12 threads, à toi de voir…)
# Si tu veux une vraie exécution parallèle (ce qui ne se justifie pas ici, à mon avis…),
# utilise plutôt ProcessPoolExecutor –*l’interface est exactement la même…
with ThreadPoolExecutor(max_workers=12) as executor:
    future = executor.map(pingAdr, listeIP)
    for res in future:
        print(res)

Si tu n’es pas encore passé à 3.2 (rhooo… c’est pô bien !), c’est moins amusant – ’faut se frotter à threading et queue :

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
import threading, Queue
import subprocess
 
def pingAdr(adresse):
#    os.chdir('c:\\')
#    a = os.popen('ping '+adresse+' -n 1 -w 500')
#    chaine=a.read()
#    a.close()
    ping_proc = subprocess.Popen(['ping', '-n 1', '-w 500 ', adresse], universal_newlines=True,
                                 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    chaine = ping_proc.stdout.read()
    ping_proc.wait() # Just in case…
    if chaine.find('ttl')>1:
        return(adresse+' : '+chaine[chaine.find('temps')+5:chaine.find('TTL')-1])
    else:
       return(adresse+' : pas de reponse')
 
listeIP = ['192.168.0.1', '192.168.0.2', '192.168.0.3', '192.168.0.4', '192.168.0.5',
           '192.168.0.6', '192.168.0.7', '192.168.0.8', '192.168.0.9', '192.168.0.10',
           '192.168.0.11', '192.168.0.12', '192.168.0.13', '192.168.0.14', '192.168.0.15',
           '192.168.0.16', '192.168.0.17', '192.168.0.18', '192.168.0.19', '192.168.0.20']
 
# Fonction “glue” entre les queues/le threading et pingAdr…
def worker(in_q, out_q):
    while not in_q.empty():
        adresse = in_q.get()
        t = pingAdr(adresse)
#        print(t)
        out_q.put(t)
        in_q.task_done()
 
# La file des données en entrée…
in_q = Queue.Queue()
# Et celle des résultats*!
out_q = Queue.Queue()
 
# On remplit la file d’entrée.
for item in listeIP:
    in_q.put(item)
 
# On lance le nombre de threads voulu.
for i in xrange(12):
     t = threading.Thread(target=worker, args=(in_q, out_q))
     t.daemon = True
     t.start()
 
# On attend que toutes les données en entrées aient été traitées.
in_q.join()
 
# Et on affiche les résultats*!
while not out_q.empty():
    print(out_q.get())

Salut,
pour info - pour passer des pings en parallèle, vous avez fping qui fait cela très bien au niveau "socket" et donc bien moins gourmand côté ressources système.
- W

Merci beaucoup, tous cela marche Impeccablement ;) 8-)
@ bientot