Disons que j'ai trois modules:
mod1 mod2 mod3
où chacun d'entre eux est infiniment long dès que mod.Launch () est appelé.
Quels sont des moyens élégants de lancer toutes ces boucles infinies à la fois, sans attendre Un à finir avant d'appeler l'autre?
Disons que j'aurais une sorte de lanceur.py, où j'essaierais de: Cela ne fonctionne évidemment pas, car il attendra le mod1.Launch () pour terminer avant de lancer Mod2.Launch (). Tout type d'aide est apprécié.
4 Réponses :
Si vous souhaitez exécuter plusieurs fonctions en parallèle, vous pouvez utiliser le MultiProcessing bibliothèque, ou Concurrent.futures.ProcesspoolEcutor . ProcessPoolExecutor utilise un multiproduction en interne, mais a une interface plus simple.
En fonction de la nature du travail effectué dans chaque tâche, la réponse varie.
Si chaque tâche est principalement ou tout io-lié, je recommanderais de multithreading.
Si chaque tâche est liée à la CPU, je recommanderais un multitraitement (en raison de la gaine en python).
Vous pouvez également utiliser filetage Module pour exécuter chaque module sur un thread séparé, mais dans le même processus: MultiProCess Module effectue un ensemble de tâches très similaire et a une API très similaire, mais utilise des processus distincts au lieu de threads, de sorte que vous pouvez également l'utiliser.
Je suggérerais d'utiliser Ray , qui est une bibliothèque pour python parallèle et distribué. Il présente des avantages sur les bibliothèques de filetage et de multipérapage standard.
Pour fournir un exemple simple exécutable, je vais utiliser des fonctions et des classes au lieu de modules, mais vous pouvez toujours envelopper le module dans une fonction ou une classe. p>
approche 1: parallèle FONCTIONS STRAND> UTILISANT import ray
import time
# Don't run this again if you've already run it.
ray.init()
@ray.remote
class Mod1(object):
def run(self):
time.sleep(3)
@ray.remote
class Mod2(object):
def run(self):
time.sleep(3)
@ray.remote
class Mod3(object):
def run(self):
time.sleep(3)
if __name__ == '__main__':
# Create 3 actors.
mod1 = Mod1.remote()
mod2 = Mod2.remote()
mod3 = Mod3.remote()
# Start the methods, these will run in parallel.
result_id1 = mod1.run.remote()
result_id2 = mod2.run.remote()
result_id3 = mod3.run.remote()
# Don't exit the interpreter before the tasks have finished.
ray.get([result_id1, result_id2, result_id3])
docs.python.org/3/library/Trireading.html