Introducción

El módulo de subprocesos en Python proporciona una interfaz de alto nivel para crear y administrar subprocesos, lo que le permite ejecutar código simultáneamente. Esto puede resultar especialmente útil para tareas que se pueden ejecutar en paralelo, como operaciones vinculadas a E/S. A continuación se muestra una lista de métodos y funciones comúnmente utilizados en el módulo de subprocesamiento, con breves ejemplos.

1. Hilo()

La clase Thread es el corazón del módulo de subprocesos. Puedes crear e iniciar nuevos hilos usando esta clase.

import threading

def print_numbers():
    for i in range(5):
        print(i)

t = threading.Thread(target=print_numbers)
t.start()  # Starts a new thread
t.join()   # Waits for the thread to finish

2. inicio()

Inicia la actividad del hilo.

t = threading.Thread(target=print_numbers)
t.start()  # Runs the target function in a separate thread

3. unirse ([tiempo de espera])

Bloquea el hilo que llama hasta que finaliza el hilo cuyo método join() se llama. Opcionalmente, puedes especificar un tiempo de espera.

t = threading.Thread(target=print_numbers)
t.start()
t.join(2)  # Waits up to 2 seconds for the thread to finish

4. está_vivo()

Devuelve Verdadero si el hilo aún se está ejecutando.

t = threading.Thread(target=print_numbers)
t.start()
print(t.is_alive())  # True if the thread is still running

5. hilo_actual()

Devuelve el objeto Thread actual, que representa el hilo que llama.

import threading

def print_current_thread():
    print(threading.current_thread())

t = threading.Thread(target=print_current_thread)
t.start()  # Prints the current thread info

6. enumerar()

Devuelve una lista de todos los objetos Thread actualmente activos.

t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_numbers)
t1.start()
t2.start()

print(threading.enumerate())  # Lists all active threads

7. recuento_activo()

Devuelve el número de objetos Thread actualmente activos.

print(threading.active_count())  # Returns the number of active threads

8. Bloquear()

Un objeto Lock es un bloqueo primitivo que se utiliza para evitar condiciones de carrera. Puedes usarlo para garantizar que solo un hilo acceda a un recurso compartido a la vez.

lock = threading.Lock()

def thread_safe_function():
    with lock:  # Acquires the lock
        # Critical section
        print("Thread-safe code")

t = threading.Thread(target=thread_safe_function)
t.start()

9. Bloqueo()

Un bloqueo reentrante permite que un hilo adquiera() el bloqueo varias veces sin bloquearse.

lock = threading.RLock()

def reentrant_function():
    with lock:
        with lock:  # Same thread can acquire the lock again
            print("Reentrant lock example")

t = threading.Thread(target=reentrant_function)
t.start()

10. Condición()

Un objeto Condición permite que los hilos esperen a que se cumpla alguna condición.

condition = threading.Condition()

def thread_wait():
    with condition:
        condition.wait()  # Wait for the condition
        print("Condition met")

def thread_notify():
    with condition:
        condition.notify()  # Notify the waiting thread

t1 = threading.Thread(target=thread_wait)
t2 = threading.Thread(target=thread_notify)
t1.start()
t2.start()

11. Evento()

Un objeto de evento se utiliza para señalar entre subprocesos. Un hilo puede esperar a que se establezca un evento y otro hilo puede configurar el evento.

event = threading.Event()

def wait_for_event():
    event.wait()  # Wait until the event is set
    print("Event has been set")

t = threading.Thread(target=wait_for_event)
t.start()
event.set()  # Set the event to allow the thread to continue

12. Semáforo()

Un objeto Semaphore le permite limitar la cantidad de subprocesos que pueden acceder a un recurso simultáneamente.

semaphore = threading.Semaphore(2)  # Only 2 threads can access the resource at once

def access_resource():
    with semaphore:
        print("Resource accessed")

t1 = threading.Thread(target=access_resource)
t2 = threading.Thread(target=access_resource)
t3 = threading.Thread(target=access_resource)

t1.start()
t2.start()
t3.start()

13. Temporizador (intervalo, función)

Un hilo de temporizador ejecuta una función después de un intervalo específico.

def delayed_function():
    print("Executed after delay")

timer = threading.Timer(3, delayed_function)
timer.start()  # Executes `delayed_function` after 3 seconds

14. establecerDaemon (Verdadero)

Los subprocesos del demonio se ejecutan en segundo plano y salen automáticamente cuando se cierra el programa principal. Puedes convertir un hilo en un demonio llamando a setDaemon(True) o pasando daemon=True al constructor Thread.

t = threading.Thread(target=print_numbers, daemon=True)
t.start()  # Daemon thread will exit when the main program ends

Conclusión

El módulo de subprocesamiento es una poderosa herramienta para manejar la concurrencia en Python. Proporciona múltiples clases y métodos para crear y controlar subprocesos, lo que facilita la ejecución de código en paralelo. Desde el uso de objetos Thread básicos hasta la gestión de la sincronización con Lock y Semaphore, este módulo es esencial para escribir programas Python simultáneos.