Uso adecuado de mutexes en Python

Estoy empezando con subprocesos múltiples en python (o al menos es posible que mi script cree varios hilos). ¿Sería este algoritmo el uso correcto de un Mutex? Todavía no he probado este código y probablemente no funcionará. Solo quiero que processData se ejecute en un subproceso (uno a la vez) y que el bucle while principal se siga ejecutando, incluso si hay un subproceso en la cola.

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 

Edición: al releer mi código puedo ver que está muy equivocado. Pero oye, por eso estoy aquí pidiendo ayuda.

No sé por qué estás usando el Mutex de Windows en lugar de Python’s. Usando los métodos de Python, esto es bastante simple:

 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() 

Pero tenga en cuenta que, debido a la architecture de CPython (es decir, el locking global de intérpretes ), solo tendrá un subproceso ejecutándose a la vez de todos modos. para liberar el locking tanto como sea posible para que el subproceso enlazado de E / S no bloquee la ejecución de otros subprocesos.

Una alternativa, para Python 2.6 y versiones posteriores, es usar el paquete de multiprocessing de Python. Refleja el paquete de threading , pero creará procesos completamente nuevos que pueden ejecutarse simultáneamente. Es trivial actualizar tu ejemplo:

 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() 

Esta es la solución que se me ocurrió:

 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 

Salida:

 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 

Tienes que desbloquear tu Mutex en algún momento …

Me gustaría mejorar un poco más la respuesta de chris-b .

Vea a continuación mi código:

 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 

En su primera ejecución, si establece thread_safe = False in while loop, mutex no se utilizará, y los hilos se pasarán por encima de los demás en el método de impresión como se muestra a continuación;

No hilo seguro

pero, si establece thread_safe = True y lo ejecuta, verá que toda la salida viene perfectamente bien;

A salvo de amenazas

espero que esto ayude.