Sincronización
Resuelve las race conditions con Lock, coordina threads con Event y aprende a reconocer y evitar deadlocks.
warning
Lock: exclusión mutua
Un Lock (o mutex) es un objeto que garantiza que solo un thread a la vez puede ejecutar una sección crítica del código. Es la solución directa a las race conditions.
Uso básico: acquire y release
lock.acquire()→ toma el lock. Si otro thread ya lo tiene, bloquea hasta que sea liberado.lock.release()→ libera el lock para que otro thread pueda tomarlo.with lock:→ equivalente a acquire/release pero automático — siempre libera el lock aunque ocurra una excepción.
python
import threading contador = 0lock = threading.Lock() # todos los threads deben usar EL MISMO lock def incrementar(n): global contador for _ in range(n): with lock: # equivalente a lock.acquire() ... lock.release() contador += 1 # seccion critica: solo un thread a la vez threads = [threading.Thread(target=incrementar, args=(100_000,)) for _ in range(5)]for t in threads: t.start()for t in threads: t.join() print(contador) # siempre 500000Todos los threads que acceden al recurso compartido deben usar la misma instancia del lock. Crear un lock nuevo por thread no tiene efecto — cada uno tendría su propio candado sin relacionarse con los demás.
Regla crítica
Lock como atributo de clase
Cuando se subclasifica Thread, una forma limpia de compartir el lock es definirlo como atributo de clase — todas las instancias comparten automáticamente el mismo objeto.
python
import threading class Escritor(threading.Thread): lock = threading.Lock() # atributo de clase: compartido entre todas las instancias registro = [] def __init__(self, nombre): super().__init__() self.nombre = nombre def run(self): with Escritor.lock: Escritor.registro.append(self.nombre) workers = [Escritor(f'w{i}') for i in range(5)]Cargando Quiz...
Cargando Quiz...
hub
Event: señales entre threads
Un Event es un flag compartido que permite a un thread señalar a otros que algo ocurrió. Es ideal para coordinar el inicio o fin de tareas, sin necesidad de proteger un recurso.
Métodos principales
event.set()→ activa el flag (pone enTrue). Desbloquea todos los threads que estén enwait().event.wait()→ bloquea hasta que el flag esté activo. Si ya está activo, retorna inmediatamente.event.clear()→ resetea el flag aFalse.event.is_set()→ retornaTruesi el flag está activo (sin bloquear).
python
import threading, time listos = threading.Event() def trabajador(nombre): print(f'{nombre}: esperando señal...') listos.wait() # bloquea hasta que el evento sea activado print(f'{nombre}: ¡arrancando!') threads = [threading.Thread(target=trabajador, args=(f'T{i}',)) for i in range(3)]warning
Deadlock
Un deadlock ocurre cuando dos o más threads quedan bloqueados indefinidamente, cada uno esperando un recurso que el otro tiene. El programa se congela sin error visible.
Deadlock con locks: espera circular
python
import threading lock_a = threading.Lock()lock_b = threading.Lock() def tarea_1(): with lock_a: # toma lock_a with lock_b: # espera lock_b... pero T2 ya lo tiene print('Tarea 1 completada') def tarea_2(): with lock_b: # toma lock_b