Richtige Verwendung von Mutexen in Python

Ich beginne mit Multi-Threads in Python (oder zumindest ist es möglich, dass mein Skript mehrere Threads erstellt). Wäre dieser Algorithmus die richtige Verwendung eines Mutex? Ich habe diesen Code noch nicht getestet und er wird wahrscheinlich nicht einmal funktionieren. Ich möchte nur, dass processData in einem Thread (einzeln) ausgeführt wird und die main while-Schleife weiter ausgeführt wird, selbst wenn sich ein Thread in der Warteschlange befindet.

from threading import Thread
from win32event import CreateMutex
mutex = CreateMutex(None, False, "My Crazy Mutex")
while(1)
    t = Thread(target=self.processData, args=(some_data,))
    t.start()
    mutex.lock()

def processData(self, data)
    while(1)
        if mutex.test() == False:
            do some stuff
            break

Bearbeiten: Wiederlesen meines Codes Ich kann sehen, dass es grob falsch ist. aber hey, deshalb bin ich hier und bitte um Hilfe.

Ich weiß nicht, warum Sie den Mutex des Fensters anstelle des Pythons verwenden. Mit den Python-Methoden ist dies ziemlich einfach:

from threading import Thread, Lock

mutex = Lock()

def processData(data):
    mutex.acquire()
    try:
        print('Do some stuff')
    finally:
        mutex.release()

while True:
    t = Thread(target = processData, args = (some_data,))
    t.start()

Beachten Sie jedoch, dass aufgrund der Architektur von CPython (nämlich der globalen Interpreter-Sperre ) ohnehin immer nur ein Thread gleichzeitig ausgeführt wird. Dies ist in Ordnung, wenn einige von ihnen E / A-gebunden sind, obwohl Sie dies wünschen um die Sperre so weit wie möglich aufzuheben, damit der E / A-gebundene Thread andere Threads nicht daran hindert, ausgeführt zu werden.

Eine Alternative für Python 2.6 und höher ist die Verwendung des Python- multiprocessingPakets. Es spiegelt das threadingPaket wider , erstellt jedoch völlig neue Prozesse, die gleichzeitig ausgeführt werden können. Es ist trivial, Ihr Beispiel zu aktualisieren:

from multiprocessing import Process, Lock

mutex = Lock()

def processData(data):
    with mutex:
        print('Do some stuff')

if __name__ == '__main__':
    while True:
        p = Process(target = processData, args = (some_data,))
        p.start()

Dies ist die Lösung, die ich mir ausgedacht habe:

import time
from threading import Thread
from threading import Lock

def myfunc(i, mutex):
    mutex.acquire(1)
    time.sleep(1)
    print "Thread: %d" %i
    mutex.release()


mutex = Lock()
for i in range(0,10):
    t = Thread(target=myfunc, args=(i,mutex))
    t.start()
    print "main loop %d" %i

Ausgabe:

main loop 0
main loop 1
main loop 2
main loop 3
main loop 4
main loop 5
main loop 6
main loop 7
main loop 8
main loop 9
Thread: 0
Thread: 1
Thread: 2
Thread: 3
Thread: 4
Thread: 5
Thread: 6
Thread: 7
Thread: 8
Thread: 9

Sie müssen Ihren Mutex irgendwann freischalten ...

Ich möchte die Antwort von chris-b noch ein bisschen verbessern .

Siehe unten für meinen Code:

from threading import Thread, Lock
import threading
mutex = Lock()


def processData(data, thread_safe):
    if thread_safe:
        mutex.acquire()
    try:
        thread_id = threading.get_ident()
        print('\nProcessing data:', data, "ThreadId:", thread_id)
    finally:
        if thread_safe:
            mutex.release()


counter = 0
max_run = 100
thread_safe = False
while True:
    some_data = counter        
    t = Thread(target=processData, args=(some_data, thread_safe))
    t.start()
    counter = counter + 1
    if counter >= max_run:
        break

Wenn Sie thread_safe = Falsein Ihrem ersten Lauf eine while-Schleife festlegen , wird kein Mutex verwendet, und die Threads werden in der folgenden Druckmethode übereinander gesetzt.

Wenn Sie es jedoch einstellen thread_safe = Trueund ausführen, werden Sie feststellen, dass die gesamte Ausgabe einwandfrei funktioniert.

hoffe das hilft.