Threading in Python | Che cos'è il threading in Python??

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

Python es genial y lo sabemos. Ma, ¿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. Se hai 16 nuclei, 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 secondo. En una máquina de un solo núcleo, debe realizar estas operaciones una por una, che significa che 16 operaciones de adición se realizan en 16 secondi. Ora, en una máquina de 16 nuclei, puede implementar las 16 operaciones de adición en cada núcleo al mismo tiempo y hacer el trabajo en 1 secondo. È chiamato 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 nucleo, 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.

Primo, 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. Nell'esempio sopra, le diremos a la CPU cómo secuenciar y ejecutar los dos subprocesos en el núcleo dado.

Infatti, puede ver la cantidad de subprocesos que se están ejecutando actualmente en su máquina. In 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?

Qualche volta, 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)
tempo.dormire(10)
Stampa('Done sleeping)
Stampa(2)

#Part Two of the code
Stampa(3)

Cuando ejecuta todo el código como un solo hilo, el código se ejecuta paso a paso. Primo, se importa la biblioteca. Entonces se imprime ‘1’. Los hilos duermen durante 10 secondi. Se imprime el siguiente “2” seguito da “Listo de dormir” y finalmente se imprime el “3”.

Produzione-
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: per impostazione predefinita, el código Python no está provisto con subprocesos; necesitamos importar el enhebrar biblioteca para hacerlo.)

Primo, 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).

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

Entonces la salida será

Produzione-
1
3
Done sleeping
2

Esempio pratico

Come sempre, 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: un: la aplicación obtiene datos del servidor, A partire dal: 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, eccetera.

Gracias al subproceso, podemos dividir los dos procesos en diferentes subprocesos. Mientras que un hilo obtiene datos (vale a dire, 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. Ad esempio, 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, per impostazione predefinita, 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):
    Stampa('Starting to sleep inside')
    tempo.dormire(secs)
    Stampa('Woke up inside')

x = threading.Thread(target = sleepy_man, args = (1,))
x.start()
Stampa(threading.activeCount())
tempo.dormire(1.2)
Stampa('Done')

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

Produzione-
Starting to sleep inside
2
Woke up inside
Done

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

• Importa la biblioteca enhebrar e tempo metereologico. enhebrar es la biblioteca que nos permitirá crear hilos y tempo metereologico es la biblioteca que contiene la función sleep.
• La funzione hombre_soñoliento toma en un argumento secondi. Primero imprime ‘Empezando a dormir adentro’. Entonces duerme por el secondi 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: obbiettivo cuál es el bloque de funciones que necesita ser enhebrado, argomenti 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,))

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

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

Stampa(threading.activeCount())

Ahora veamos el flujo de control. Una vez que llame al cominciare() metodo, 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):
    Stampa('Starting to sleep inside')
    tempo.dormire(secs)
    Stampa('Woke up inside')

x = threading.Thread(target = sleepy_man, args = (4,))
x.start()
Stampa(threading.activeCount())
tempo.dormire(1.2)
Stampa('Done')

L'output è il seguente:

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):
    Stampa('Starting to sleep inside - Iteration {}'.formato(5-secs))
    tempo.dormire(secs)
    Stampa('Woke up inside - Iteration {}'.formato(5-secs))

per io nel raggio d'azione(3):
    x = threading.Thread(target = sleepy_man, args = (5-io,))
    x.start()

Stampa('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

Imparentato