Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 34 de 47 · Concurrencia: hilos, procesos y async ✦ WebMCP implementado

multiprocessing y concurrent.futures

10 min de lectura 3 retos

Si los hilos esperan bien pero calculan mal por el GIL, los procesos calculan bien: cada uno es un programa Python entero, con su memoria y su propio GIL, y de verdad corren a la vez en varios núcleos. Aquí ves multiprocessing, cómo viajan los datos entre procesos y la interfaz cómoda de concurrent.futures, que sirve igual para hilos y para procesos.

¿De dónde vienen los nombres?

multiprocessing = multi- (varios) + processing (procesar)
El módulo que crea y reparte trabajo entre varios procesos del sistema, con una interfaz parecida a la de threading.
fork = inglés fork (horquilla, bifurcación)
Una forma de crear un proceso hijo en Linux: el sistema parte en dos el proceso actual, y los dos siguen desde el mismo punto. En PHP lo hace pcntl_fork().
spawn = inglés spawn (desovar, engendrar)
Otra forma: arranca un Python nuevo desde cero y le dice qué importar. Es la de Windows y macOS.
pickle = inglés pickle (encurtir, conservar en vinagre)
Convierte un objeto en bytes para guardarlo o enviarlo (como serialize() de PHP) y lo reconstruye al otro lado. Así viajan los datos entre procesos.
Future = inglés future (futuro)
Una «promesa»: el resultado de algo que aún no ha terminado. Preguntas done() y, cuando llegue, result().
Executor y Pool = executor (ejecutor) y pool (piscina, grupo)
Un grupo de trabajadores ya arrancados a quienes les mandas tareas, en vez de crear uno nuevo para cada cosa.
En 4 ideas
1/4

Un proceso es otra cocina entera: memoria propia y GIL propio. Por eso es la herramienta para calcular en varios núcleos. PHP-FPM ya trabaja así: un proceso por petición.

1 · Un proceso es otra cocina entera

Vuelve al restaurante. Un hilo era otro cocinero en tu misma cocina, con un solo juego de llaves (el GIL). Un proceso es una cocina nueva: su propia nevera, sus propios fuegos y su propio juego de llaves. Dos cocinas no se estorban, y por eso dos procesos que calculan sí trabajan a la vez en dos núcleos.

El módulo multiprocessing los crea con la misma forma que los hilos: Process, start() y join(). Como los procesos no comparten memoria, el resultado se devuelve por una cola (Queue), una especie de ventanilla entre las dos cocinas:

Pythonmain.pySolo lectura: necesita procesos del sistema
import multiprocessing as mp


def cuenta_hechas(tareas, salida):
    salida.put(sum(1 for tarea in tareas if tarea["hecha"]))


if __name__ == "__main__":
    tareas = [
        {"titulo": "pan", "hecha": True},
        {"titulo": "banco", "hecha": False},
        {"titulo": "python", "hecha": True},
    ]
    salida = mp.Queue()
    proceso = mp.Process(target=cuenta_hechas, args=(tareas, salida))
    proceso.start()
    print("hechas:", salida.get())
    proceso.join()
    print("código de salida:", proceso.exitcode)
$ python main.py
hechas: 2
código de salida: 0
  1. El hijo recibe una copia de la lista tareas. Si la cambia, el padre no se entera.
  2. Para devolver algo hay que mandarlo por la cola: salida.put(...) en el hijo y salida.get() en el padre.
  3. proceso.exitcode vale 0 si el hijo terminó sin errores.
  4. Este ejemplo es de solo lectura: el navegador no puede lanzar procesos. La salida es la real, con python main.py.

¿Por qué? · En PHP no existe

¿Por qué hace falta if __name__ == "__main__": al crear procesos? En PHP no existe

En Windows, macOS y (desde Python 3.14) también en Linux para ProcessPoolExecutor, los procesos nuevos se crean arrancando Python otra vez (spawn o forkserver) e importando tu fichero para encontrar la función que debe ejecutar.

Si al importar tu fichero se volviera a ejecutar todo lo de arriba, cada hijo crearía sus propios hijos, y estos otros más: una bomba de procesos. El truco que viste en la primera lección, if __name__ == "__main__":, lo evita: lo de dentro solo corre en el proceso original.

En PHP, pcntl_fork() copia el proceso ya arrancado y no vuelve a leer el script, así que no hace falta nada parecido. Python también puede hacerlo con fork en algunos sistemas, pero ya no es la opción por defecto en Linux para los executors.

2 · Entre procesos nada se comparte: todo viaja copiado

Cada cocina tiene su despensa. Para pasar algo de una a otra hay que empaquetarlo, enviarlo y desempaquetarlo. En Python ese empaquetado es pickle (el serialize() y unserialize() de PHP). Lo que llega al otro lado es una copia, no el mismo objeto:

Pythonmain.py
import pickle

original = {"id": 1, "titulo": "Comprar pan"}
llega = pickle.loads(pickle.dumps(original))

print("igual:", llega == original)
print("el mismo objeto:", llega is original)

try:
    pickle.dumps(lambda tarea: tarea["titulo"])
except (pickle.PicklingError, AttributeError):
    print("una lambda no se puede enviar")
  1. El diccionario que llega es igual pero no es el mismo (is da False): se ha copiado. Es lo que ve el proceso hijo.
  2. Una lambda (o una función definida dentro de otra) no se puede empaquetar: pickle guarda las funciones por su nombre, y la lambda no tiene uno que se pueda buscar luego.
  3. Consecuencia práctica: a un ProcessPoolExecutor solo le puedes pasar funciones definidas en el nivel superior del fichero y datos que se puedan empaquetar.

3 · concurrent.futures: la interfaz cómoda para hilos y procesos

Crear Process, colas y join a mano es pesado. La biblioteca estándar tiene una capa más cómoda, concurrent.futures, con dos clases gemelas:

#ClaseUsa…Para…
1ThreadPoolExecutorUn grupo de hilosEsperar E/S (red, disco)
2ProcessPoolExecutorUn grupo de procesosCalcular en varios núcleos

Las dos se usan igual. submit(funcion, *args) manda una tarea y devuelve un Future; map(funcion, lista) manda muchas y devuelve los resultados en el mismo orden que la lista (aunque terminen desordenadas). El with cierra el grupo al salir, esperando a que acaben:

Pythonmain.pySolo lectura: necesita hilos del sistema
from concurrent.futures import ThreadPoolExecutor


def carga(id):
    return {"id": id, "titulo": f"Tarea {id}"}


with ThreadPoolExecutor(max_workers=3) as pool:
    futuro = pool.submit(carga, 7)
    todas = pool.map(carga, [1, 2, 3])
    print(futuro.result())
    print([t["titulo"] for t in todas])
$ python main.py
{'id': 7, 'titulo': 'Tarea 7'}
['Tarea 1', 'Tarea 2', 'Tarea 3']

Y con procesos, cambiando solo el nombre de la clase (y poniendo la protección de __main__):

Pythonmain.pySolo lectura: necesita procesos del sistema
from concurrent.futures import ProcessPoolExecutor


def cuadrados(n):
    return sum(i * i for i in range(n))


if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=2) as pool:
        resultados = list(pool.map(cuadrados, [10, 100, 1000]))
    print(resultados)
$ python main.py
[285, 328350, 332833500]

El Future en sí no necesita hilos: es solo una caja que empieza vacía y se rellena después. Puedes verlo funcionar aquí en el navegador, completándolo a mano:

Pythonmain.py
from concurrent.futures import Future

futuro = Future()
print("¿terminado?", futuro.done())

futuro.add_done_callback(lambda f: print("aviso:", f.result()))
futuro.set_result("Comprar pan")

print("¿terminado?", futuro.done())
print("resultado:", futuro.result())

roto = Future()
roto.set_exception(ValueError("tarea sin título"))
print("error guardado:", roto.exception())
  1. done() dice si ya hay resultado; result() lo da (y espera si aún no está).
  2. Si la tarea falló, el Future guarda el error: result() lo vuelve a lanzar y exception() te lo da sin lanzarlo. Es como un try/catch que viaja con el resultado.
  3. add_done_callback registra una función que se llama sola al terminar.

4 · ¿Compensa un proceso? Repartir y juntar

Un proceso hijo tarda milisegundos en arrancar y cuesta memoria. Si la tarea dura un microsegundo, tardarás más en lanzarla que en hacerla. La receta que funciona tiene tres pasos: trocear los datos, calcular cada trozo en un proceso y juntar los resultados parciales.

Pythonmain.py
tareas = ["pan", "banco", "python", "gimnasio", "leche"]
n_procesos = 2

# En PHP: array_chunk() reparte por bloques; esto reparte de uno en uno, como las cartas
trozos = [tareas[i::n_procesos] for i in range(n_procesos)]
print(trozos)

parciales = [len(trozo) for trozo in trozos]
print(parciales, sum(parciales))

Esa receta es el truco de siempre para CPU: lo que PHP-FPM hace con las peticiones (un proceso para cada una), tú lo haces con los datos. Compara cómo se crea un proceso hijo en cada lenguaje:

PHP 8.5fork.php
<?php
declare(strict_types=1);

$pid = pcntl_fork();
if ($pid === -1) {
    exit("No se pudo crear el proceso");
}
if ($pid === 0) {
    echo "hijo: preparo las tareas" . PHP_EOL;
    exit(0);
}

pcntl_waitpid($pid, $estado);
echo "padre: el hijo ha terminado" . PHP_EOL;
Pythonmain.pySolo lectura: necesita procesos del sistema
import multiprocessing as mp


def prepara():
    print("hijo: preparo las tareas")


if __name__ == "__main__":
    hijo = mp.Process(target=prepara)
    hijo.start()
    hijo.join()
    print("padre: el hijo ha terminado")
  1. Las dos salidas son iguales: primero el hijo y, cuando acaba, el padre.
  2. pcntl_fork() (extensión pcntl, solo en la consola) parte el proceso en dos y devuelve 0 al hijo y el número del hijo al padre. pcntl_waitpid es el join().
  3. En Python no «bifurcas» a mano: pasas la función a Process(target=...) y el módulo elige la forma de crearlo según el sistema.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Rellena un Future

Un Future es una caja vacía que se rellena después. Completa el futuro con el texto Comprar pan (con set_result) y luego imprime futuro.done() y futuro.result(), uno por línea. Debe salir True y después Comprar pan.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. Un proceso tiene memoria y GIL propios: calcula en varios núcleos (en PHP-FPM, cada petición ya es un proceso).
  2. Entre procesos los datos viajan copiados con pickle (el serialize() de PHP); una lambda no viaja y el fichero necesita if __name__ == "__main__":.
  3. ThreadPoolExecutor y ProcessPoolExecutor se usan igual: submit → Future, map → resultados en orden, with para cerrar.
  4. Un Future es una caja que se rellena después: done(), result(), exception(). Si la tarea falla, guarda el error.
  5. Arrancar y enviar datos cuesta: troceas, calculas en paralelo y juntas, solo si la tarea es pesada.

Para recordarlo: «Trocea, Calcula, Junta»

TTrocea
los datos en trozos pequeños
CCalcula
un trozo en cada proceso
JJunta
los resultados parciales

Los procesos son cocinas distintas: nada se comparte, todo se envía. Por eso mandas trozos y recoges resultados pequeños.