IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Problème Multi thread Python 3.2


Sujet :

Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Profil pro
    Étudiant
    Inscrit en
    Février 2010
    Messages
    21
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2010
    Messages : 21
    Par défaut 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

  2. #2
    Membre Expert

    Homme Profil pro
    Diverses et multiples
    Inscrit en
    Mai 2008
    Messages
    662
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Diverses et multiples

    Informations forums :
    Inscription : Mai 2008
    Messages : 662
    Par défaut
    Le code ! Le code ! Le code !

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

  3. #3
    Membre averti
    Profil pro
    Étudiant
    Inscrit en
    Février 2010
    Messages
    21
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2010
    Messages : 21
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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)

  4. #4
    Membre Expert

    Homme Profil pro
    Diverses et multiples
    Inscrit en
    Mai 2008
    Messages
    662
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Diverses et multiples

    Informations forums :
    Inscription : Mai 2008
    Messages : 662
    Par défaut
    Ok, alors voici ce que je propose (sous python 3.2):

    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
    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 : 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
    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())

  5. #5
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 704
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 704
    Par défaut
    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
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  6. #6
    Membre averti
    Profil pro
    Étudiant
    Inscrit en
    Février 2010
    Messages
    21
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2010
    Messages : 21
    Par défaut
    Merci beaucoup, tous cela marche Impeccablement
    @ bientot

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Problème multi threading
    Par tlibert dans le forum Windows Forms
    Réponses: 1
    Dernier message: 25/02/2008, 23h42
  2. Problème Seveur multi-thread
    Par Doom2Darkness dans le forum C++
    Réponses: 14
    Dernier message: 05/06/2007, 19h32
  3. problme de multi thread
    Par L4BiN dans le forum Concurrence et multi-thread
    Réponses: 22
    Dernier message: 25/04/2007, 16h47
  4. Effectuer du multi THREAD en python
    Par parp1 dans le forum Général Python
    Réponses: 3
    Dernier message: 10/05/2006, 12h56
  5. Réponses: 11
    Dernier message: 14/02/2006, 00h26

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo