thread - Uso apropiado de mutexes en Python

start() python

Question

Estoy comenzando con multi-hilos en python (o al menos es posible que mi script cree múltiples hilos). ¿Sería este algoritmo el uso correcto de un Mutex? Todavía no he probado este código y probablemente ni siquiera funcionará. Solo quiero que processData se ejecute en un hilo (uno a la vez) y el ciclo while principal para seguir ejecutándose, incluso si hay un hilo 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

Editar: volver a leer mi código. Puedo ver que está muy mal. pero oye, es por eso que estoy aquí pidiendo ayuda.

Answer 1

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

Answer 2

Me gustaría mejorar la answer de un poco más.

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 en while loop, no se usará mutex, y los hilos se thread_safe = False entre sí en el método de impresión como se muestra a continuación;

pero, si configura thread_safe = True y lo ejecuta, verá que todos los resultados vienen perfectamente bien;

espero que esto ayude.

Answer 3

No sé por qué estás usando el Mutex de Window en lugar de Python. 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 arquitectura de CPython (es decir, el bloqueo de intérprete global ), de hecho tendrá solo un hilo ejecutándose a la vez: esto está bien si varios de ellos están vinculados a E / S, aunque querrá para liberar el bloqueo tanto como sea posible para que el hilo enlazado de E / S no bloquee la ejecución de otros subprocesos.

Una alternativa, para Python 2.6 y posterior, es usar el paquete de multiprocessing de Python. Refleja el paquete de threading , pero creará procesos completamente nuevos que se pueden ejecutar 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()

Answer 4

Tienes que desbloquear tu Mutex en algún momento ...