Zwei Funktionen, die parallel mit mehreren Argumente und return-Werte

Habe ich zwei getrennte Funktionen. Jeder von Ihnen dauert eine lange Zeit zum ausführen.

def function1(arg):
     do_some_stuff_here
     return result1

def function2(arg1, arg2, arg3):
     do_some_stuff_here
     return result2

Ich würde gerne, Sie zu starten parallel Ihre Ergebnisse (wissen, was was ist) und verarbeiten Sie die Ergebnisse danach. Für das, was ich verstanden habe, multiprocessing ist effizienter als das Threading in Python 2.7 (GIL im Zusammenhang mit Ausgabe). Aber ich bin ein wenig verloren, ob es besser ist die Verwendung von Prozess -, Pool-oder Queue-und wie Sie Sie implementieren können, in einem richtigen pythonic way für meinen Anwendungsfall.

Jede Hilfe dankbar 😉

  • Die GIL stört CPU-gebundene Vorgänge aber nicht wirklich Auswirkungen IO-Operationen gebunden. Welche Art von Sachen sind, Ihre Funktionen zu tun?
  • Die Funktionen haben die gleiche Allgemeine Art von Sachen : Holen Sie sich die Daten via http-request, speichern Sie diese im Speicher, einige Verarbeitung und schalten Sie Sie in den numpy-array.
  • „Allgemein“ ist nicht sehr spezifisch. Probieren Sie beide threading und multiprocessing und sehen, ob es einen Unterschied bei den APIs für die Verwendung beider Module sind ähnlich.
InformationsquelleAutor PsychicLocust | 2017-04-18



2 Replies
  1. 8

    Zunächst, Prozess -, Pool-und Queue-alle haben unterschiedliche Verwendung.

    Prozess wird verwendet, um spawn ein Prozess durch die Schaffung der Prozess-Objekt.

    from multiprocessing import Process
    
    def method1():
        print "in method1"
        print "in method1"
    
    def method2():
        print "in method2"
        print "in method2"
    
    p1 = Process(target=method1) # create a process object p1
    p1.start()                   # starts the process p1
    p2 = Process(target=method2)
    p2.start()

    Pool wird verwendet, um zu parallelisieren, die Ausführung der Funktion über mehrere
    input-Werte.

    from multiprocessing import Pool
    
    def method1(x):
        print x
        print x**2
        return x**2
    
    p = Pool(3)
    result = p.map(method1, [1,4,9]) 
    print result          # prints [1, 16, 81]

    Warteschlange wird verwendet, um Kommunikation zwischen Prozessen.

    from multiprocessing import Process, Queue
    
    def method1(x, l1):
        print "in method1"
        print "in method1"
        l1.put(x**2)
        return x
    
    def method2(x, l2):
        print "in method2"
        print "in method2"
        l2.put(x**3)
        return x
    
    l1 = Queue()
    p1 = Process(target=method1, args=(4, l1, ))  
    l2 = Queue()
    p2 = Process(target=method2, args=(2, l2, )) 
    p1.start()   
    p2.start()      
    print l1.get()          # prints 16
    print l2.get()          # prints 8

    Nun für Ihren Fall, die Sie verwenden können, Prozess – & Queue(3. Methode) oder Sie manipulieren können, die pool-Methode arbeiten (siehe unten)

    import itertools
    from multiprocessing import Pool
    import sys
    
    def method1(x):         
        print x
        print x**2
        return x**2
    
    def method2(x):        
        print x
        print x**3
        return x**3
    
    def unzip_func(a, b):  
        return a, b    
    
    def distributor(option_args):
        option, args = unzip_func(*option_args)    # unzip option and args 
    
        attr_name = "method" + str(option)            
        # creating attr_name depending on option argument
    
        value = getattr(sys.modules[__name__], attr_name)(args) 
        # call the function with name 'attr_name' with argument args
    
        return value
    
    
    option_list = [1,2]      # for selecting the method number
    args_list = [4,2]        
    # list of arg for the corresponding method, (argument 4 is for method1)
    
    p = Pool(3)              # creating pool of 3 processes
    
    result = p.map(distributor, itertools.izip(option_list, args_list)) 
    # calling the distributor function with args zipped as (option1, arg1), (option2, arg2) by itertools package
    print result             # prints [16,8]

    Hoffe, das hilft.

    • Alle meine Probleme verschwunden, wegen dieser Antwort. Danke vsri293!
  2. 0

    Dies ist ein weiteres Beispiel, das ich gerade gefunden, hoffe es hilft, einfach und schön 😉

    from multiprocessing import Pool
    
    def square(x):
        return x * x
    
    def cube(y):
        return y * y * y
    
    pool = Pool(processes=20)
    
    result_squares = pool.map_async(square, range(10))
    result_cubes = pool.map_async(cube, range(10))
    
    print result_squares.get(timeout=3)
    print result_cubes.get(timeout=3)

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.