Cola de subprocesamiento de Python

1. Hilos en Python
2. Limitar subprocesos con una cola en Python

Este tutorial discutirá cómo limitar la cantidad de subprocesos activos en Python.

Hilos en Python

La creación de subprocesos en Python permite que varios subprocesos de ejecución se ejecuten simultáneamente dentro de un solo proceso. Cada subproceso se ejecuta independientemente de los demás, lo que permite una ejecución simultánea y un rendimiento mejorado.

La creación de subprocesos es particularmente útil para ejecutar tareas que están vinculadas a E/S o que tienen un tiempo de ejecución prolongado, ya que permite que otros subprocesos continúen ejecutándose mientras un subproceso está bloqueado.

Python proporciona un módulo integrado de hilos para crear y administrar hilos. La clase Thread dentro del módulo se puede usar para crear un nuevo hilo de ejecución, y el método start() se puede usar para comenzar la ejecución del hilo.

El método join() se puede utilizar para esperar a que un hilo termine su ejecución.

Además del módulo threading, Python también proporciona el módulo concurrent.futures, que proporciona una interfaz de nivel superior para ejecutar invocables de forma asíncrona. Este módulo proporciona la clase ThreadPoolExecutor, que se puede usar para crear un grupo de subprocesos de trabajo que se pueden usar para ejecutar invocables en paralelo.

La creación de subprocesos puede ser una herramienta poderosa para mejorar el rendimiento de los programas de Python, pero debe usarse con precaución, ya que también puede introducir complejidad y el potencial de condiciones de carrera y otros problemas de sincronización.

Limitar subprocesos con una cola en Python

La clase Queue en Python proporciona una estructura de datos segura para subprocesos y FIFO (primero en entrar, primero en salir) para almacenar elementos que deben ser procesados por múltiples subprocesos. Se puede utilizar para coordinar el flujo de datos entre subprocesos y para limitar el número de subprocesos que se pueden ejecutar al mismo tiempo.

Si queremos limitar el número de subprocesos que se pueden ejecutar simultáneamente usando una cola, podemos usar el parámetro maxsize dentro de la clase Queue. Este es un ejemplo de cómo usar una cola para limitar el número total de subprocesos.

import threading
import queue
from queue import Queue
from threading import Thread


def function_to_be_executed():
    print(f"Thread {threading.get_ident()} is working")
    return


q = Queue(maxsize=3)

for i in range(10):
    try:
        thread = Thread(target=function_to_be_executed)
        q.put(thread, block=False)
    except queue.Full:
        q.get().join(timeout=0)
        thread = Thread(target=function_to_be_executed)
        q.put(thread, block=False)
    thread = q.get()
    thread.start()
while not q.empty():
    thread = q.get()
    thread.join(timeout=1)

Producción :

Thread 140368505984768 is working
Thread 140368497592064 is working
Thread 140368505984768 is working
Thread 140368497592064 is working
Thread 140368505984768 is working
Thread 140368497592064 is working
Thread 140368514377472 is working
Thread 140368497592064 is working
Thread 140368497592064 is working
Thread 140368497592064 is working

El código anterior crea un objeto Cola con un tamaño máximo de 3, lo que significa que solo 3 subprocesos pueden estar en la cola en un momento dado. Luego, se crean 10 hilos y se agregan a la cola usando el método put().

El ciclo while inicia los subprocesos en la cola uno por uno, y el método join() se utiliza para esperar a que finalicen todos los subprocesos.

En este ejemplo, solo se ejecutan 3 subprocesos simultáneamente; el resto esperará en la cola hasta que tengan la oportunidad de correr. Podemos ajustar el tamaño máximo de la cola y el número de subprocesos para satisfacer nuestras propias necesidades.