Python sharing eine Sperre zwischen Prozessen

Question

Ich versuche, eine partielle Funktion zu verwenden, so dass pool.map() eine Funktion mit mehr als einem Parameter (in diesem Fall ein Lock() Objekt) zielen kann. Hier

ist Codebeispiel (aus einer Antwort auf eine frühere Anfrage von mir):

from functools import partial 

def target(lock, iterable_item): 
    for item in items: 
     # Do cool stuff 
     if (... some condition here ...): 
      lock.acquire() 
      # Write to stdout or logfile, etc. 
      lock.release() 

def main(): 
    iterable = [1, 2, 3, 4, 5] 
    pool = multiprocessing.Pool() 
    l = multiprocessing.Lock() 
    func = partial(target, l) 
    pool.map(func, iterable) 
    pool.close() 
    pool.join() 

Jedoch, wenn ich diesen Code ausführen, erhalte ich die Fehlermeldung:

Runtime Error: Lock objects should only be shared between processes through inheritance. 

Was bin ich hier fehlt? Wie kann ich die Sperre zwischen meinen Teilprozessen teilen?

Answer 1

Entschuldigung, ich hätte dies in meiner Antwort auf Ihre andere Frage erwischt. Sie können normale multiprocessing.Lock Objekte nicht an Methoden Pool übergeben, da sie nicht gebeizt werden können. Es gibt zwei Möglichkeiten, dies zu umgehen. Eine davon ist Manager() zu erstellen und übergibt ein Manager.Lock():

def main(): 
    iterable = [1, 2, 3, 4, 5] 
    pool = multiprocessing.Pool() 
    m = multiprocessing.Manager() 
    l = m.Lock() 
    func = partial(target, l) 
    pool.map(func, iterable) 
    pool.close() 
    pool.join() 

Dies ist ein bisschen Schwergewicht, obwohl; Bei Verwendung von Manager muss ein anderer Prozess zum Hosten des Servers Manager gestartet werden. Und alle Anrufe an acquire/release das Schloss müssen zu diesem Server über IPC gesendet werden.

Die andere Option besteht darin, die reguläre multiprocessing.Lock() zur Zeit der Poolerstellung zu übergeben, mit dem initializer Kwarg. Dies wird Ihre Sperre Instanz global in allen Kinderarbeiter machen:

def target(iterable_item): 
    for item in items: 
     # Do cool stuff 
     if (... some condition here ...): 
      lock.acquire() 
      # Write to stdout or logfile, etc. 
      lock.release() 
def init(l): 
    global lock 
    lock = l 

def main(): 
    iterable = [1, 2, 3, 4, 5] 
    l = multiprocessing.Lock() 
    pool = multiprocessing.Pool(initializer=init, initargs=(l,)) 
    pool.map(target, iterable) 
    pool.close() 
    pool.join() 

Die zweite Lösung hat den Nebeneffekt, nicht mehr erforderlich partial.