1. `multiprocesamiento`: Esta es generalmente la mejor opción para tareas unidas a CPU (tareas que pasan la mayor parte de su tiempo haciendo cálculos). Crea múltiples procesos, cada uno con su propio intérprete, permitiendo un verdadero paralelismo y omitiendo el bloqueo del intérprete global (GIL) que limita el roscado en Cpython.
`` `Python
importar multiprocesamiento
Def process_item (elemento):
"" "La función se ejecutará en paralelo". ""
# Su código para procesar un solo elemento va aquí.
resultado =elemento * 2 # Ejemplo:duplique el elemento
Resultado de retorno
Si __name__ =='__main__':# importante para la compatibilidad de Windows
Elementos =rango (10)
con multiprocesamiento.pool (procesos =multiprocessing.cpu_count ()) como grupo:
Resultados =Pool.map (Process_item, elementos)
Imprimir (resultados)
`` `` ``
* `El multiprocesamiento.pool` crea un grupo de procesos de trabajadores.
* `Pool.map` aplica` Process_item` a cada elemento en 'elementos' simultáneamente. Devuelve una lista de los resultados en el mismo orden que la entrada.
* `multiprocesamiento.cpu_count ()` determina el número de núcleos de CPU, lo que permite un paralelismo óptimo. Puede especificar un número menor de procesos si es necesario.
2. `concurrente.futures`: Esto proporciona una interfaz de nivel superior tanto para los hilos como para los procesos, que ofrece más flexibilidad. Para las tareas con destino a CPU, querrá usar `ProcessPoolExecutor`.
`` `Python
importación concurrente.
Def process_item (elemento):
"" "La función se ejecutará en paralelo". ""
# Su código para procesar un solo elemento va aquí.
resultado =elemento * 2 # Ejemplo:duplique el elemento
El elemento de retorno, el resultado #return tanto la entrada como la salida para rastrear
Si __name__ =='__main__':
Elementos =rango (10)
con concurrent.futures.processpoolexecutor () como ejecutor:
resultados =ejecutor.map (process_item, elementos) #order preservado
Para el ítem, resulta en resultados:
print (f "entrada:{elemento}, salida:{resultado}")
`` `` ``
`Concurrent.futures` ofrece más control, especialmente con` ejecutor.submit` para tareas individuales y excepciones de manejo.
3. `Threading` (generalmente no recomendado para tareas unidas a CPU): Threading es adecuado para tareas de E/S (tareas que pasan la mayor parte de su tiempo esperando recursos externos como solicitudes de red o operaciones de disco). Debido al GIL, los hilos en Cpython no proporcionan un verdadero paralelismo para las tareas unidas a la CPU.
`` `Python
Importación de hilo
Def process_item (elemento, resultados):
#Su código para procesar un solo elemento va aquí.
resultado =elemento * 2 #example:duplique el elemento
Results.append (resultado)
Si __name__ =='__main__':
Elementos =rango (10)
Resultados =[]
Hilos =[]
Para el artículo en los artículos:
Thread =Threading.Thread (Target =Process_item, args =(item, resultados))
Threads.append (hilo)
Thread.Start ()
Para hilo en hilos:
Thread.Join ()
Imprimir (resultados)
`` `` ``
Este ejemplo utiliza una lista compartida (`` Resultados ') que necesita una consideración cuidadosa para la seguridad de los subprocesos (usando bloqueos si es necesario). Es más complejo que `multiprocesamiento` o` concurrente.futures` para cargas de trabajo unidas a CPU y probablemente no les proporcionará un impulso de rendimiento.
Elegir el método correcto:
* CPU-Bound: Use `multiprocesamiento` o` concurrente.futures` con `processpoolexecutor`. El `multiprocesamiento 'es generalmente más simple para operaciones de estilo sencillas de reducción de mapas.
* I/O-Bound: Use `Threading` o` concurrent.futures` con `threadpoolexecutor`. `Concurrent.futures` ofrece un mejor manejo y control de excepciones.
* Mixto: Puede ser necesario un enfoque híbrido, combinando procesos para piezas e hilos intensivos en CPU para piezas de E/S.
Recuerde manejar posibles excepciones dentro de las funciones de sus trabajadores y considerar la sobrecarga de la creación y la gestión de procesos o hilos. Para tareas muy pequeñas, la sobrecarga podría superar los beneficios de la paralelización. Perfente su código para determinar si la paralelización realmente proporciona una mejora del rendimiento.