Multithreading y Multiprocesamiento en Python: Guía Completa

Si alguna vez has tenido que procesar miles de archivos, hacer cientos de peticiones HTTP o acelerar un algoritmo pesado, sabes que el Python tradicional (síncrono) puede ser frustrantemente lento. ¿La solución? Concurrencia y paralelismo. En esta guía completa, dominarás el multithreading y el multiprocesamiento en Python, entendiendo cuándo y cómo usar cada técnica para exprimir al máximo el rendimiento de tu código.

Exploraremos desde los conceptos fundamentales — hilos, procesos y el famoso GIL — hasta implementaciones prácticas con ThreadPoolExecutor, ProcessPoolExecutor, locks y queues. Al final, tendrás un arsenal completo para escribir código Python paralelo de verdad.

Entendiendo Hilos y Procesos

Antes de escribir código, necesitamos entender qué son los hilos y los procesos — y por qué la diferencia entre ellos es crucial en Python.

Un proceso es una instancia de un programa en ejecución. Cada proceso tiene su propio espacio de memoria, sus propios recursos y está aislado de los demás. Piensa en abrir Chrome tres veces: cada ventana es un proceso separado. Los procesos son pesados de crear, pero totalmente independientes.

Un hilo (o thread) es la unidad más pequeña de procesamiento dentro de un proceso. Todos los hilos de un mismo proceso comparten el mismo espacio de memoria. Piensa en pestañas dentro de una misma ventana de Chrome: todas comparten recursos, pero pueden bloquearse entre sí si no se gestionan adecuadamente.

En Python, esta distinción es aún más importante debido a una peculiaridad de la implementación estándar: el GIL.

El GIL (Global Interpreter Lock)

El Global Interpreter Lock es un mecanismo de CPython (la implementación estándar de Python) que permite que solo un hilo ejecute bytecode de Python a la vez. Esto significa que para tareas CPU-bound (tareas pesadas de procesamiento), múltiples hilos no aportan ganancias de rendimiento — de hecho, pueden incluso empeorar el rendimiento debido al overhead de cambio entre hilos.

Entonces, ¿por qué usar hilos en Python? La respuesta está en las tareas I/O-bound: operaciones de entrada y salida como peticiones HTTP, lectura de archivos o consultas a bases de datos. Durante estas operaciones, el hilo permanece inactivo esperando una respuesta, y el GIL se libera — permitiendo que otros hilos ejecuten. Aquí es donde el multithreading brilla.

Para entender el GIL más a fondo, te recomiendo leer What Is the Python Global Interpreter Lock (GIL)? en Real Python, que explica el tema de forma clara y detallada.

Multithreading con threading.Thread

El módulo threading proporciona la API básica para crear y gestionar hilos en Python. Comencemos con un ejemplo sencillo:

import threading
import time

def tarea(nombre, segundos):
    print(f"Hilo {nombre}: iniciando")
    time.sleep(segundos)
    print(f"Hilo {nombre}: completado tras {segundos}s")

hilos = []
for i in range(5):
    t = threading.Thread(target=tarea, args=(f"H{i}", i + 1))
    hilos.append(t)
    t.start()

for t in hilos:
    t.join()

print("¡Todos los hilos completados!")

Llamamos a start() para iniciar cada hilo y a join() para esperar que todos terminen antes de continuar. Sin join(), el programa principal podría finalizar antes de que los hilos hijos completen su trabajo.

La documentación oficial del módulo threading cubre todos los detalles sobre locks, semáforos, eventos y otros mecanismos de sincronización.

Subclases de Thread

Un enfoque más organizado es crear subclases de Thread:

import threading

class MiDescarga(threading.Thread):
    def __init__(self, url):
        super().__init__()
        self.url = url
        self.resultado = None

    def run(self):
        import time
        time.sleep(2)
        self.resultado = f"Datos de {self.url}"

descargas = [MiDescarga(f"https://api.ejemplo.com/item/{i}") for i in range(10)]
for d in descargas:
    d.start()
for d in descargas:
    d.join()
    print(d.resultado)

Este enfoque es especialmente útil cuando necesitas encapsular estado y comportamiento en objetos reutilizables.

ThreadPoolExecutor: La Manera Moderna

Gestionar hilos manualmente funciona, pero es tedioso. El módulo concurrent.futures, introducido en Python 3.2 y mejorado significativamente con el tiempo, ofrece una API mucho más elegante a través del ThreadPoolExecutor:

from concurrent.futures import ThreadPoolExecutor
import time

def descargar_archivo(url):
    print(f"Descargando: {url}")
    time.sleep(2)
    return f"Contenido de {url}"

urls = [f"https://sitio.com/archivo_{i}.zip" for i in range(20)]

with ThreadPoolExecutor(max_workers=5) as executor:
    resultados = list(executor.map(descargar_archivo, urls))

print(f"¡Descargados {len(resultados)} archivos correctamente!")

El ThreadPoolExecutor gestiona automáticamente un pool de hilos reutilizables. El parámetro max_workers define cuántos hilos se mantienen en el pool. Con el gestor de contexto (with), los hilos se finalizan automáticamente al salir del bloque.

También puedes usar submit() para obtener objetos Future, que permiten seguir el progreso de cada tarea individualmente:

from concurrent.futures import ThreadPoolExecutor, as_completed

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = {executor.submit(descargar_archivo, url): url for url in urls}
    for future in as_completed(futures):
        url = futures[future]
        try:
            resultado = future.result()
            print(f"{url} completado: {resultado[:30]}...")
        except Exception as e:
            print(f"{url} falló: {e}")

Consulta la documentación oficial de concurrent.futures para explorar todas las funciones avanzadas, incluyendo callbacks y timeouts.

Sincronización: Locks y Queues

Cuando múltiples hilos comparten datos, surgen condiciones de carrera (race conditions). Dos hilos pueden intentar modificar la misma variable al mismo tiempo, corrompiendo el resultado. La solución clásica es usar locks:

import threading

contador = 0
lock = threading.Lock()

def incrementar():
    global contador
    for _ in range(100000):
        with lock:
            contador += 1

hilos = [threading.Thread(target=incrementar) for _ in range(10)]
for t in hilos:
    t.start()
for t in hilos:
    t.join()

print(f"Contador final: {contador}")  # Siempre 1.000.000

Sin el lock, el resultado sería impredecible — probablemente menor a 1.000.000 — debido a las condiciones de carrera. El gestor de contexto with lock garantiza que el lock siempre se libere, incluso en caso de excepciones.

Para la comunicación entre hilos, la cola (queue.Queue) es la herramienta ideal. Ya es thread-safe, eliminando la necesidad de locks manuales:

from queue import Queue
import threading
import time

def productor(cola):
    for i in range(10):
        item = f"Item {i}"
        cola.put(item)
        print(f"Producido: {item}")
        time.sleep(0.5)
    cola.put(None)  # Señal de fin

def consumidor(cola):
    while True:
        item = cola.get()
        if item is None:
            break
        print(f"Consumido: {item}")
        time.sleep(1)
    print("Consumidor finalizado")

cola = Queue()
t_productor = threading.Thread(target=productor, args=(cola,))
t_consumidor = threading.Thread(target=consumidor, args=(cola,))

t_productor.start()
t_consumidor.start()
t_productor.join()
t_consumidor.join()

El patrón productor-consumidor con colas es extremadamente versátil y aparece en aplicaciones reales como procesamiento de logs, web scraping y tuberías ETL. La documentación oficial del módulo queue detalla los tipos de cola disponibles: FIFO, LIFO y colas con prioridad.

Para profundizar en más patrones de concurrencia, consulta también nuestra guía completa sobre context managers en Python, que muestra cómo usar el patrón with para gestionar recursos de forma segura.

Multiprocesamiento con ProcessPoolExecutor

Para tareas que exigen mucho procesamiento de la CPU (CPU-bound) — como procesamiento de imágenes, cálculos científicos o machine learning — el multithreading no ayuda debido al GIL. La solución es el multiprocesamiento, que crea procesos separados, cada uno con su propio intérprete de Python y su propio GIL.

El ProcessPoolExecutor del módulo concurrent.futures ofrece la misma API elegante que ThreadPoolExecutor, pero usando procesos en lugar de hilos:

from concurrent.futures import ProcessPoolExecutor
import math

def contar_primos(limite):
    primos = []
    for num in range(2, limite):
        if all(num % i != 0 for i in range(2, int(math.sqrt(num)) + 1)):
            primos.append(num)
    return len(primos)

intervalos = [10000, 20000, 30000, 40000, 50000, 60000]

with ProcessPoolExecutor(max_workers=4) as executor:
    resultados = list(executor.map(contar_primos, intervalos))

for intervalo, total in zip(intervalos, resultados):
    print(f"Primos hasta {intervalo}: {total}")

La diferencia de rendimiento en tareas CPU-bound es dramática. Mientras que los hilos estarían limitados por el GIL y ejecutarían el trabajo prácticamente de forma secuencial, los procesos distribuyen el trabajo entre los núcleos de la CPU, logrando ganancias lineales de rendimiento.

Es importante notar que ProcessPoolExecutor tiene algunas limitaciones: los argumentos y valores de retorno de las funciones deben ser picklable (serializables), y el overhead de creación de procesos es mayor que el de los hilos. Para tareas muy pequeñas, el costo de crear el proceso puede superar el beneficio.

La documentación oficial del módulo multiprocessing ofrece funciones más avanzadas como colas entre procesos, memoria compartida y conexiones pipe para escenarios que requieren mayor control.

Otro recurso que puede complementar tu conocimiento es la guía sobre args y kwargs en Python, fundamental para crear funciones flexibles que funcionan bien con los executors.

Multithreading vs Multiprocesamiento: Cuándo Usar Cada Uno

Elegir entre hilos y procesos es una de las decisiones más importantes en la programación concurrente de Python. Aquí tienes un resumen práctico:

Usa Multithreading cuando:

• La tarea es I/O-bound (peticiones HTTP, lectura de archivos, consultas a bases de datos)
• Necesitas compartir estado entre tareas con frecuencia
• El número de tareas simultáneas es muy grande (miles)
• El overhead de creación debe ser mínimo

Usa Multiprocesamiento cuando:

• La tarea es CPU-bound (procesamiento de imágenes, cálculos matemáticos)
• Necesitas aprovechar múltiples núcleos de la CPU
• La transferencia de datos entre tareas es pequeña
• El aislamiento entre procesos es deseable (seguridad, estabilidad)

El artículo Difference Between Multithreading vs Multiprocessing in Python en GeeksforGeeks ofrece una tabla comparativa detallada que puede ayudarte a decidir.

Ejemplo Práctico: Web Scraping Concurrente

Unamos todo en un ejemplo realista: un web scraper que descarga múltiples páginas simultáneamente:

from concurrent.futures import ThreadPoolExecutor, as_completed
import requests
import time

def scrape_url(url):
    try:
        resp = requests.get(url, timeout=10)
        return url, resp.status_code, len(resp.text)
    except Exception as e:
        return url, None, str(e)

urls = [
    "https://python.org",
    "https://docs.python.org/3/",
    "https://pypi.org",
    "https://realpython.com",
    "https://github.com/python",
    "https://stackoverflow.com/questions/tagged/python",
    "https://www.geeksforgeeks.org/python-programming-language/",
    "https://pandas.pydata.org",
]

print("Iniciando scraping síncrono...")
inicio = time.time()
for url in urls:
    resultado = scrape_url(url)
    print(f"{resultado[0]}: {resultado[1]}")
print(f"Tiempo síncrono: {time.time() - inicio:.2f}s")

print("\nIniciando scraping concurrente...")
inicio = time.time()
with ThreadPoolExecutor(max_workers=4) as executor:
    futures = {executor.submit(scrape_url, url): url for url in urls}
    for future in as_completed(futures):
        url, status, datos = future.result()
        print(f"{url}: {status}")
print(f"Tiempo concurrente: {time.time() - inicio:.2f}s")

La diferencia de tiempo entre la versión síncrona y la concurrente es impresionante. En pruebas reales, el scraping con ThreadPoolExecutor suele ser de 3 a 8 veces más rápido, dependiendo del número de URLs y la latencia de la red.

La guía de concurrencia en Python de Real Python expande estos ejemplos con benchmarks y comparaciones detalladas entre threading, multiprocessing y asyncio.

Buenas Prácticas y Errores Comunes

La concurrencia es poderosa, pero también trae desafíos. Estos son los errores más comunes y cómo evitarlos:

1. Compartición excesiva de estado: Cuanto menos estado compartido entre hilos/procesos, mejor. Prefiere pasar datos como argumentos y devolver resultados, en lugar de modificar variables globales.

2. Olvidar el join(): Siempre espera a que tus hilos/procesos terminen con join() o usando gestores de contexto.

3. Deadlocks: Cuando dos hilos esperan mutuamente que el otro libere un lock. Usa with lock y evita adquirir múltiples locks al mismo tiempo.

4. Exceso de workers: Crear demasiados hilos o procesos degrada el rendimiento. Para tareas I/O-bound, el doble de hilos que el número de CPUs suele funcionar bien; para CPU-bound, usa el número de núcleos de tu máquina.

5. Ignorar excepciones en hilos: Las excepciones dentro de los hilos no se propagan automáticamente al hilo principal. Usa siempre future.result() o try/except dentro de la función objetivo.

Para un estudio más profundo sobre multithreading en Python, el tutorial Multithreading in Python de GeeksforGeeks cubre desde lo básico hasta temas avanzados como semáforos y barreras de sincronización.

Consideraciones de Rendimiento

Aquí tienes una tabla práctica de referencia para elegir la herramienta correcta:

Conclusión

Dominar el multithreading y el multiprocesamiento es esencial para cualquier desarrollador Python que quiera escribir aplicaciones eficientes y escalables. En esta guía, aprendiste:

• La diferencia fundamental entre hilos (mismo espacio de memoria) y procesos (espacio aislado)
• Cómo el GIL impacta cada enfoque
• Cómo usar ThreadPoolExecutor para tareas I/O-bound
• Cómo usar ProcessPoolExecutor para tareas CPU-bound
• Técnicas de sincronización con locks y colas
• Patrones prácticos como productor-consumidor
• Ejemplos reales de web scraping concurrente

El secreto del código concurrente exitoso está en elegir la herramienta correcta para cada tipo de tarea. Comienza con ThreadPoolExecutor para operaciones de I/O y evoluciona a ProcessPoolExecutor cuando necesites procesar datos pesados. Y recuerda: mide siempre el rendimiento antes y después — ¡la optimización prematura es la raíz de todos los males!

¿Te gustó la guía? Explora otros tutoriales en el blog Universo Python para seguir mejorando tus habilidades en programación concurrente y otros temas avanzados del lenguaje.