Subprocesamiento en Python | ¿Qué es Threading en Python?

Threading en Python: haga que su código sea más inteligente

Python es genial y lo sabemos. Pero, ¿puede hacerse lo suficientemente inteligente en aspectos de procesamiento? El enhebrado muestra el camino.

¿Qué es el paralelismo?

Las máquinas anteriores solían tener un solo núcleo dentro de la CPU donde solía tener lugar todo el procesamiento.

¿Por qué es importante la cantidad de núcleos? Es porque indica la capacidad de la máquina para manejar múltiples cosas. Si tiene 16 núcleos, puede realizar 16 operaciones diferentes al mismo tiempo.

Supongamos que desea realizar 16 operaciones de suma diferentes y supongamos que cada operación toma 1 segundo. En una máquina de un solo núcleo, debe realizar estas operaciones una por una, lo que significa que las 16 operaciones de adición se realizan en 16 segundos. Ahora, en una máquina de 16 núcleos, puede implementar las 16 operaciones de adición en cada núcleo al mismo tiempo y hacer el trabajo en 1 segundo. Se llama Paralelismo.

Enhebrar

Hilo es un conjunto de operaciones que debe ejecutarse. El hilo se implementará en uno de los núcleos de la CPU. Nota: 1 hilo se puede implementar solo en 1 núcleo, no se puede transferir / cambiar de diente

Desplieguemos dos hilos en un núcleo. Nota: un núcleo solo puede hacer una cosa a la vez.

Ahora podemos procesar los dos hilos de la forma que queramos.

Primero, podemos procesar la mitad del primer hilo.

La mitad del siguiente hilo se puede procesar ahora.

La mitad restante de los hilos se puede procesar de manera similar.

Esto es lo que es el enhebrado Así es como ejecutamos diferentes cosas en el mismo núcleo de CPU. TLDR- Threading trata sobre cómo manejamos los hilos en un núcleo.

Nota- La ejecución de subprocesos no implica la ejecución en varios núcleos. Se trata de cómo secuenciar el conjunto de programas (subprocesos) en el mismo núcleo. En el ejemplo anterior, le diremos a la CPU cómo secuenciar y ejecutar los dos subprocesos en el núcleo dado.

De hecho, puede ver la cantidad de subprocesos que se están ejecutando actualmente en su máquina. En Windows: vaya a Administrador de tareas → Rendimiento → CPU.

¿Por qué necesitamos enhebrar? ¿Por qué no podemos procesar un hilo a la vez y pasar al siguiente?

A veces, un hilo puede quedar colgado, lo que significa que se supone que está inactivo en ese momento. El mejor ejemplo es la función time.sleep (), que no hace nada más que esperar un tiempo determinado. Mientras un hilo está inactivo / colgado, podemos seguir adelante y procesar el otro hilo hasta que el hilo anterior se active. TLDR: cuando un subproceso está esperando, puede procesar el otro subproceso mientras tanto.

Esto es exactamente lo que llamamos CComputación actual.

Un pequeño ejemplo

Expliquemos el enhebrado con un pequeño ejemplo. Mire el fragmento de código a continuación.

#Part One of the code
import time
print(1)
time.sleep(10)
print('Done sleeping)
print(2)

#Part Two of the code
print(3)

Cuando ejecuta todo el código como un solo hilo, el código se ejecuta paso a paso. Primero, se importa la biblioteca. Entonces se imprime ‘1’. Los hilos duermen durante 10 segundos. Se imprime el siguiente «2» seguido de «Listo de dormir» y finalmente se imprime el «3».

Output-
1
Done sleeping
2
3

Ahora digamos que está ejecutando el código como dos hilos. La primera parte como hilo y la segunda como hilo. (Nota: de forma predeterminada, el código Python no está provisto con subprocesos; necesitamos importar el enhebrar biblioteca para hacerlo.)

Primero, se importa la biblioteca y luego se imprime ‘1’. Ahora el hilo se va a dormir. Aquí es donde entra en acción el enhebrado.

El núcleo ahora cambia al otro hilo.

Ahora se imprime ‘3’. Dado que todo el proceso se realiza en el subproceso 2, el núcleo ahora vuelve al subproceso 1 (que todavía está en suspensión).

Ahora, después de la duración del sueño, se imprime ‘2’.

Entonces la salida será

Output-
1
3
Done sleeping
2

Ejemplo practico

Como siempre, un concepto solo es claro cuando lo explicamos con un ejemplo del mundo real. Los procesos de E / S son los que se benefician del subproceso.

Supongamos que está viendo Shawshank Redemption en Netflix. Ahora suceden dos cosas mientras ve a Andy Dufresne sufrir en la cárcel: una: la aplicación obtiene datos del servidor, dos: los datos obtenidos se le muestran como una película en la pantalla.

Imagínese cuál sería la situación sin enhebrar. Tendría que esperar a que el video se descargue de vez en cuando, ver el segmento que se obtuvo, esperar a que se descargue el siguiente segmento, etc.

Gracias al subproceso, podemos dividir los dos procesos en diferentes subprocesos. Mientras que un hilo obtiene datos (es decir, está en modo de suspensión / suspensión), el otro hilo puede mostrarle el asombroso rendimiento de Morgan Freeman.

También es muy útil para usted como científico de datos. Por ejemplo, cuando extrae los datos de varias páginas web, simplemente puede implementarlos en varios subprocesos y hacerlo más rápido. Incluso cuando envía los datos a un servidor, puede hacerlo en varios subprocesos, de modo que cuando un subproceso está inactivo, se pueden activar otros.

Un ejemplo detallado

Como se dijo antes, de forma predeterminada, el código de Python no está provisto con subprocesos; necesitamos importar la biblioteca de subprocesos para hacerlo.

Eche un vistazo al código.

import threading
import time

def sleepy_man(secs):
    print('Starting to sleep inside')
    time.sleep(secs)
    print('Woke up inside')

x = threading.Thread(target = sleepy_man, args = (1,))
x.start()
print(threading.activeCount())
time.sleep(1.2)
print('Done')

Si ejecuta el código anterior, obtendrá el siguiente resultado.

Output-
Starting to sleep inside
2
Woke up inside
Done

Primero, déjame explicarte el código paso a paso. Luego analizaremos la salida.

• Importa la biblioteca enhebrar y tiempo. enhebrar es la biblioteca que nos permitirá crear hilos y tiempo es la biblioteca que contiene la función sleep.
• La función hombre_soñoliento toma en un argumento segundos. Primero imprime ‘Empezando a dormir adentro’. Entonces duerme por el segundos segundos y luego imprime ‘Desperté por dentro’.
• Esta es la parte donde comenzamos a crear hilos. Necesitamos definir llamando a la clase hilo de rosca. Necesitamos pasar dos argumentos: objetivo cuál es el bloque de funciones que necesita ser enhebrado, argumentos cuáles son los argumentos que deben pasarse a la función. Se devuelve un objeto de hilo que ahora se almacena en x.

x = threading.Thread(target = sleepy_man, args = (10,))

• Ahora, después de definir la clase de hilo, necesitamos llamar a la función comienzo() para iniciar el enhebrado

• Nota- Ahora tenemos dos hilos. Un hilo predeterminado para el programa y un
  nuevo hilo que definimos. Por tanto, el número de hilos activos es dos.
• Por lo tanto, la declaración debe imprimir ‘2’.

print(threading.activeCount())

Ahora veamos el flujo de control. Una vez que llame al comienzo() método, dispara hombre_soñoliento () y se ejecuta en un hilo separado. El programa principal también se ejecutará en paralelo como otro hilo. El flujo se muestra en la imagen a continuación.

Ahora aumentemos el tiempo en el que el programa duerme dentro de la función.

import threading
import time

def sleepy_man(secs):
    print('Starting to sleep inside')
    time.sleep(secs)
    print('Woke up inside')

x = threading.Thread(target = sleepy_man, args = (4,))
x.start()
print(threading.activeCount())
time.sleep(1.2)
print('Done')

La salida es la siguiente:

Starting to sleep inside
2
Done
Woke up inside

El flujo se da en el diagrama a continuación:

Ahora condimentemos un poco las cosas. Ejecutemos un bucle for que active varios subprocesos.

import threading
import time

def sleepy_man(secs):
    print('Starting to sleep inside - Iteration {}'.format(5-secs))
    time.sleep(secs)
    print('Woke up inside - Iteration {}'.format(5-secs))

for i in range(3):
    x = threading.Thread(target = sleepy_man, args = (5-i,))
    x.start()

print('Active threads- ', threading.activeCount())

Starting to sleep inside - Iteration 0
Starting to sleep inside - Iteration 1
Starting to sleep inside - Iteration 2
Active threads-  4
Woke up inside - Iteration 2
Woke up inside - Iteration 1
Woke up inside - Iteration 0

Relacionado