Python Academy · Lección

Conceptos básicos de multiprocessing

Use varios núcleos de CPU

Conceptos básicos de multiprocessing es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

¿Por qué multiprocessing?

El GIL impide que los hilos ejecuten bytecode de Python en paralelo. El módulo multiprocessing evita esta limitación al iniciar procesos independientes, cada uno con su propio intérprete y GIL, de modo que el trabajo limitado por la CPU se ejecuta realmente en varios núcleos.

import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())

Iniciar un proceso

Process(target=func) refleja la API de threading. Llame a start() para iniciarlo y a join() para esperar.

import multiprocessing as mp

def worker():
    print('hello from a child process')

if __name__ == '__main__':
    p = mp.Process(target=worker)
    p.start()
    p.join()
    print('parent done')

La protección de main

En algunas plataformas, los procesos hijo importan su script. Sin una protección if __name__ == '__main__':, puede crear procesos de forma recursiva. Incluya siempre el código de inicio dentro de ella.

import multiprocessing as mp

def task(n):
    print('processing', n)

if __name__ == '__main__':
    for i in range(3):
        p = mp.Process(target=task, args=(i,))
        p.start()
        p.join()

Pasar argumentos

Utilice args para los argumentos posicionales y kwargs para los argumentos con nombre, igual que con los hilos. Los argumentos se serializan con pickle y se envían al proceso hijo.

import multiprocessing as mp

def show(label, times):
    for _ in range(times):
        print(label)

if __name__ == '__main__':
    p = mp.Process(target=show, args=('hi',), kwargs={'times': 2})
    p.start()
    p.join()

Un grupo de procesos de trabajo

multiprocessing.Pool gestiona un grupo de procesos. pool.map reparte un iterable entre ellos y recopila los resultados en orden.

import multiprocessing as mp

def square(n):
    return n * n

if __name__ == '__main__':
    with mp.Pool(processes=2) as pool:
        print(pool.map(square, range(6)))

ProcessPoolExecutor

La API concurrent.futures también ofrece ProcessPoolExecutor, con la misma interfaz submit/map que ha visto para los hilos.

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

if __name__ == '__main__':
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(cube, range(5))))

Espacios de memoria independientes

Cada proceso tiene su propia memoria. Modificar una variable global en un proceso hijo no cambia la copia del proceso padre. Los datos deben devolverse o compartirse explícitamente.

import multiprocessing as mp

counter = 0

def bump():
    global counter
    counter += 100

if __name__ == '__main__':
    p = mp.Process(target=bump)
    p.start()
    p.join()
    print('parent counter still:', counter)

Obtener los resultados

Como la memoria no se comparte, devuelva los resultados mediante Pool.map, ejecutores o colas, en lugar de modificar variables globales.

import multiprocessing as mp

def double(n):
    return n * 2

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        results = pool.map(double, [1, 2, 3, 4])
    print('results:', results)

apply_async para llamadas individuales

apply_async programa una llamada y devuelve un identificador del resultado. Llame a .get() para recuperar el valor.

import multiprocessing as mp

def add(a, b):
    return a + b

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        r = pool.apply_async(add, (3, 4))
        print(r.get())

Requisito de serialización con pickle

Los destinos y argumentos deben ser serializables con pickle para poder atravesar el límite entre procesos. Las funciones de nivel superior funcionan; las expresiones lambda y las funciones locales normalmente no.

import multiprocessing as mp

def top_level(n):
    return n + 1

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        print(pool.map(top_level, [10, 20]))

Cuándo elegir procesos

Utilice procesos para trabajos limitados por la CPU: cálculos matemáticos, procesamiento de imágenes y análisis sintáctico. La sobrecarga de iniciar procesos y serializar con pickle hace que sean adecuados para menos tareas y más pesadas, en lugar de muchas tareas pequeñas.

import multiprocessing as mp

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

if __name__ == '__main__':
    with mp.Pool() as pool:
        print(pool.map(heavy, [1000, 2000, 3000]))

Comprobación rápida

Compruebe su comprensión de multiprocessing.

Resumen

Ha aprendido los conceptos básicos de multiprocessing:

Los procesos evitan el GIL y permiten un paralelismo real de la CPU.
Utilice la protección if __name__ == '__main__'.
Pool y ProcessPoolExecutor distribuyen el trabajo y recopilan los resultados.
La memoria no se comparte; los argumentos deben poder serializarse con pickle.

A continuación: compartir datos de forma segura con colas y bloqueos.

Preguntas frecuentes

¿La lección «Conceptos básicos de multiprocessing» es gratis?

Sí — el texto completo de «Conceptos básicos de multiprocessing» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conceptos básicos de multiprocessing»?

Use varios núcleos de CPU Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Conceptos básicos de multiprocessing»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Python Academy