Très simple simultanées de la programmation en Python

J'ai un simple script Python qui utilise deux beaucoup plus compliqué de scripts Python, et fait quelque chose avec les résultats.

J'ai deux modules, Foo et Bar, et mon code est comme suit:

import Foo
import Bar

output = []

a = Foo.get_something()
b = Bar.get_something_else()

output.append(a)
output.append(b)

Ces deux méthodes prennent du temps à s'exécuter, et l'un ne dépend de l'autre, de sorte que la solution la plus évidente consiste à exécuter en parallèle. Comment puis-je réaliser cela, mais assurez-vous que la commande est maintenue: Selon l'une des finitions de première doit attendre que les autres pour terminer avant que le script puisse continuer.

Laissez-moi savoir si je n'ai pas fait moi-même assez clair, j'ai essayé de rendre le code d'exemple aussi simple que possible.

EDIT:

Merci Ambre, votre solution fonctionne avec une légère modification.

Au lieu d'appeler la méthode start() sur chaque fil quand il est créé, j'ai configurer comme suit:

threadname = threading.Thread(target=foo)
threadname.start()

Sans cela, j'ai été l'obtention de l'erreur AttributeError: 'NoneType' object has no attribute 'join' et certains très comportement bizarre avec la simultanéité. Si vous modifiez votre réponse ci-dessous, je vais le marquer comme résolu.

OriginalL'auteur Rory | 2012-05-07

  1. 22

    En général, vous pouvez utiliser enfilage pour ce faire.

    Tout d'abord, créer un thread pour chaque chose que vous souhaitez exécuter en parallèle:

    import threading

import Foo
import Bar

results = {}

def get_a():
    results['a'] = Foo.get_something()
a_thread = threading.Thread(target=get_a)
a_thread.start()

def get_b():
    results['b'] = Bar.get_something_else()
b_thread = threading.Thread(target=get_b)
b_thread.start()

    Ensuite, afin d'exiger d'eux de l'avoir terminé, utilisez .join() sur les deux:

    a_thread.join()
b_thread.join()

    à quel point vos résultats seront results['a'] et results['b'], donc si vous voulez une liste ordonnée:

    output = [results['a'], results['b']]

    Remarque: si les deux tâches sont intrinsèquement CPU-intensive, vous pourriez envisager de multitraitement au lieu - en raison de Python GIL, un Python processus n'utilisez jamais un cœur de PROCESSEUR, alors que multiprocessing pouvez distribuer les tâches pour séparer les noyaux. Cependant, il est légèrement plus élevée de surcharge que threading, et donc si les tâches sont moins gourmandes en ressources PROCESSEUR, il pourrait ne pas être aussi efficace.

    Le filetage est utile pour le code avec la marche au ralenti. Si elle a beaucoup de lourds calcul, vous devez en aviser le multitraitement, parce que le filetage ne fera qu'ajouter des décalages dans ce cas.
    Bien sûr, je peux le modifier dans une note à ce sujet.
    Oui, c'est très consommateur d'UC. Je vais les faire ce travail tout d'abord; j'ai eu un coup d'oeil rapide et l'Api sont identiques.
    J'ai essayé pendant un certain temps maintenant, mais je suis constamment à l'obtention de l'erreur: AttributeError: 'NoneType' object has no attribute 'join' C'est en se référant à a_thread à chaque fois. b_thread fonctionne comme prévu.
    J'ai édité le code légèrement, il y avait un léger problème avec elle.

    OriginalL'auteur Amber

  2. 8
    import multiprocessing

import Foo
import Bar

results = {}

def get_a():
    results['a'] = Foo.get_something()



def get_b():
    results['b'] = Bar.get_something_else()

process_a = multiprocessing.Process(target=get_a)
process_b = multiprocessing.Process(target=get_b)


process_b.start()
process_a.start()


process_a.join
process_b.join

    Ici est la version de processus de votre programme.

    REMARQUE: le filetage des structures de données de sorte que vous avez à vous soucier de blocage qui évite l'erreur de manipulation de données ainsi que l'ambre mentionné ci-dessus, il a aussi un GIL (Global interprète de Verrouillage) problème et depuis deux de vos tâches sont UC, alors cela signifie qu'il faudra plus de temps en raison des appels de notification, les fils du fil d'acquisition et de distribution. Toutefois, si vos tâches gourmandes en e/S il n'a pas d'effet tant que ça.

    Maintenant, étant donné qu'il n'existe pas de structures de données partagées dans un processus donc aucune inquiétude sur les VERROUS et depuis il fonctionne indépendamment de la GIL de sorte que vous appréciez réellement le pouvoir réel des multiprocesseurs.

    Simple remarque à retenir: le processus est le même que le fil juste sans partage des structures de données (tout fonctionne dans l'isolement et se concentre sur la messagerie.)

    découvrez dabeaz.com il a donné une bonne présentation sur la programmation simultanée d'une fois.

    OriginalL'auteur fazkan