Zwei parallele Abläufe von sequentiellen Prozessen

Question

Ich habe mehrere Prozesse, sagen A_step1, A_step2, B_step1, B_step2 ... Sie müssen so laufen, dass Schritt1 beendet werden muss, bevor Schritt2 zu laufen beginnt. Folgendes habe ich getan:

from subprocess import check_call 
check_call(A_step1) 
check_call(A_step2) 
check_call(B_step1) 
check_call(B_step2) 

Ich möchte jedoch, dass A- und B-Prozesse parallel ablaufen. Gibt es das überhaupt in Python?

Vielen Dank

Answer 1

Sie können sich wahrscheinlich damit verbundenen Prozesse in Funktion setzen und sie dann asynchron laufen. Für den asynchronen Teil würde ich das multiprocessing Modul

Answer 2

empfehlen. Eine allgemeine Strategie besteht darin, Warteschlangen als einen Mechanismus zu verwenden, um einem Koordinator zu erlauben, Arbeit zu erledigen und Mitarbeitern zu ermöglichen, dem Koordinator zu sagen wenn sie etwas abgeschlossen haben.

Hier ist ein vereinfachtes Beispiel. Sie können mit den zufälligen Schlafzeiten experimentieren, um sich davon zu überzeugen, dass keine der Schritte von Schritt 2 beginnt, bis beide Arbeiter ihre Schritt-1-Jobs beendet haben.

from multiprocessing import Process, Manager 
from time import sleep 
from random import randint 

def main(): 

    # Some queues so that we can tell the workers to advance 
    # to the next step, and so that the workers to tell 
    # us when they have completed a step. 
    workQA = Manager().Queue() 
    workQB = Manager().Queue() 
    progQ = Manager().Queue() 

    # Start the worker processes. 
    pA = Process(target = workerA, args = (workQA, progQ)) 
    pB = Process(target = workerB, args = (workQB, progQ)) 
    pA.start() 
    pB.start() 

    # Step through some work. 
    for step in (1, 2): 
     workQA.put(step) 
     workQB.put(step) 
     done = [] 
     while True: 
      item_done = progQ.get() 
      print item_done 
      done.append(item_done) 
      if len(done) == 2: 
       break 

    # Tell the workers to stop and wait for everything to wrap up. 
    workQA.put('stop') 
    workQB.put('stop') 
    pA.join() 
    pB.join() 

def workerA(workQ, progQ): 
    do_work('A', workQ, progQ) 

def workerB(workQ, progQ): 
    do_work('B', workQ, progQ) 

def do_work(worker, workQ, progQ): 
    # Of course, in your real code the two workers won't 
    # be doing the same thing. 
    while True: 
     step = workQ.get() 
     if step == 1: 
      do_step(worker, step, progQ) 
     elif step == 2: 
      do_step(worker, step, progQ) 
     else: 
      return 

def do_step(worker, step, progQ): 
    n = randint(1, 5) 
    msg = 'worker={} step={} sleep={}'.format(worker, step, n) 
    sleep(n) 
    progQ.put(msg) 

main() 

Beispiel Ausgang:

worker=B step=1 sleep=2 
worker=A step=1 sleep=4 
worker=A step=2 sleep=1 
worker=B step=2 sleep=3