Lección 34 de 47 · Concurrencia: hilos, procesos y async✦ WebMCP implementado
multiprocessing y concurrent.futures
10 min de lectura3 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.
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.
Entre procesos no se comparte nada: los datos se copian y viajan convertidos en bytes con pickle (el serialize() de PHP). Una lambda no viaja, y el programa necesita if __name__ == "__main__":.
concurrent.futures lo hace cómodo: submit devuelve un Future y map devuelve los resultados en orden. Cambiar ThreadPoolExecutor por ProcessPoolExecutor cambia hilos por procesos con una sola palabra.
Arrancar un proceso cuesta (milisegundos y memoria) y enviar datos también: compensa solo si la tarea es pesada. Para esperar, hilos o asyncio.
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
defcuenta_hechas(tareas, salida):
salida.put(sum(1for 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
El hijo recibe una copia de la lista tareas. Si la cambia, el padre no se entera.
Para devolver algo hay que mandarlo por la cola: salida.put(...) en el hijo y salida.get() en el padre.
proceso.exitcode vale 0 si el hijo terminó sin errores.
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")
El diccionario que llega es igual pero no es el mismo (is da False): se ha copiado. Es lo que ve el proceso hijo.
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.
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:
#
Clase
Usa…
Para…
1
ThreadPoolExecutor
Un grupo de hilos
Esperar E/S (red, disco)
2
ProcessPoolExecutor
Un grupo de procesos
Calcular 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 importThreadPoolExecutordefcarga(id):
return {"id": id, "titulo": f"Tarea {id}"}
withThreadPoolExecutor(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])
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 importProcessPoolExecutordefcuadrados(n):
returnsum(i * i for i inrange(n))
if __name__ == "__main__":
withProcessPoolExecutor(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:
done() dice si ya hay resultado; result() lo da (y espera si aún no está).
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.
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 inrange(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
<?phpdeclare(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
defprepara():
print("hijo: preparo las tareas")
if __name__ == "__main__":
hijo = mp.Process(target=prepara)
hijo.start()
hijo.join()
print("padre: el hijo ha terminado")
Las dos salidas son iguales: primero el hijo y, cuando acaba, el padre.
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().
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 · ✓ Resuelto
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
Pista.futuro.set_result("Comprar pan") antes de los print, y añade un segundo print(futuro.result()).
Reto 2 de 3 · ✓ Resuelto
Trocear las tareas
Antes de repartir trabajo entre procesos hay que trocear los datos. Escribe trocea(lista, tamano): devuelve una lista de listas con tamano elementos cada una (la última puede tener menos). trocea([1, 2, 3, 4, 5], 2) da [[1, 2], [3, 4], [5]]. Si tamano es 0 o negativo, lanza ValueError. Es el array_chunk() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Una comprensión con range(0, len(lista), tamano) y la rebanada lista[i:i + tamano]. No olvides el raise ValueError primero.
Reto 3 de 3 · ✓ Resuelto
Juntar los resultados parciales
Cada proceso devuelve un diccionario con cuántas tareas ha visto por etiqueta, por ejemplo {"casa": 1, "trabajo": 2}. Escribe combina(parciales): recibe la lista de esos diccionarios y devuelve uno solo con las cantidades sumadas. combina([{"casa": 1, "trabajo": 2}, {"casa": 2, "ocio": 1}]) da {"casa": 3, "trabajo": 2, "ocio": 1}. Es la parte «juntar» de «trocea, calcula, junta».
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Dos for anidados: parcial.items() da pares; suma con total[etiqueta] = total.get(etiqueta, 0) + cantidad.
Resumen
Lo que te llevas de esta lección
Un proceso tiene memoria y GIL propios: calcula en varios núcleos (en PHP-FPM, cada petición ya es un proceso).
Entre procesos los datos viajan copiados con pickle (el serialize() de PHP); una lambda no viaja y el fichero necesita if __name__ == "__main__":.
ThreadPoolExecutor y ProcessPoolExecutor se usan igual: submit → Future, map → resultados en orden, with para cerrar.
Un Future es una caja que se rellena después: done(), result(), exception(). Si la tarea falla, guarda el error.
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.