Einfädeln in Python | Was ist Threading in Python??

Teilen auf Facebook
Teilen auf twittern
Teilen auf verlinktin
Teilen auf Telegramm
Teilen auf WhatsApp

Inhalt

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

Python es genial y lo sabemos. Aber, ¿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. Wenn Sie haben 16 Kerne, 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 Sekunde. En una máquina de un solo núcleo, debe realizar estas operaciones una por una, was bedeutet, dass 16 operaciones de adición se realizan en 16 Sekunden. Jetzt, en una máquina de 16 Kerne, puede implementar las 16 operaciones de adición en cada núcleo al mismo tiempo y hacer el trabajo en 1 Sekunde. Benannt Parallelität.

Enhebrar

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

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

1d5wqvcsyf4f74mgt2g_k_g-8327670

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

Zuerst, podemos procesar la mitad del primer hilo.

1i_fogu8psxcsklkalrapxg-6670733

La mitad del siguiente hilo se puede procesar ahora.

1myabkoktklk8zsv-z_ddyw-6315981

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

1ly2quxkj5r45r50aeipz0g-9476205

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.

Notiz- 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. Im obigen Beispiel, le diremos a la CPU cómo secuenciar y ejecutar los dos subprocesos en el núcleo dado.

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

Manchmal, 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)
zeit.schlaf(10)
drucken('Done sleeping)
drucken(2)

#Part Two of the code
drucken(3)

Cuando ejecuta todo el código como un solo hilo, el código se ejecuta paso a paso. Zuerst, se importa la biblioteca. Entonces se imprime ‘1’. Los hilos duermen durante 10 Sekunden. Se imprime el siguiente “2” gefolgt von “Listo de dormiry finalmente se imprime el “3”.

Ausgabe-
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. (Notiz: standardmäßig, el código Python no está provisto con subprocesos; necesitamos importar el enhebrar biblioteca para hacerlo.)

Zuerst, 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.

1z6k2rdchniexyauc9mr4ha-8942500

El núcleo ahora cambia al otro hilo.

1cy3uh65nbl8wnwwdihdmxq-7134652

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

1uxcednvax6f506e3ht-fpq-6985366

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

Entonces la salida será

Ausgabe-
1
3
Done sleeping
2

Praxisbeispiel

Wie immer, 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: ein: la aplicación obtiene datos del servidor, Von: los datos obtenidos se le muestran como una película en la pantalla.

1g8rkyd8cytziwiazj0ka_q-5516699

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 (nämlich, 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. Zum Beispiel, 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, standardmäßig, 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):
    drucken('Starting to sleep inside')
    zeit.schlaf(secs)
    drucken('Woke up inside')

x = threading.Thread(Ziel = sleepy_man, Argumente = (1,))
x.start()
drucken(threading.activeCount())
zeit.schlaf(1.2)
drucken('Done')

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

Ausgabe-
Starting to sleep inside
2
Woke up inside
Done

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

  • Importa la biblioteca enhebrar Ja Wetter. enhebrar es la biblioteca que nos permitirá crear hilos y Wetter es la biblioteca que contiene la función sleep.
  • Die Funktion schläfriger_mann toma en un argumento Sekunden. Primero imprime ‘Empezando a dormir adentro’. Entonces duerme por el Sekunden 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: Zielsetzung cuál es el bloque de funciones que necesita ser enhebrado, Argumente 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(Ziel = sleepy_man, Argumente = (10,))
  • Jetzt, después de definir la clase de hilo, necesitamos llamar a la función Anfang() para iniciar el enhebrado
  • Notiz- Ahora tenemos dos hilos. Un hilo predeterminado para el programa y un
    nuevo hilo que definimos. Deswegen, el número de hilos activos es dos.
  • Deswegen, la declaración debe imprimir ‘2’.
drucken(threading.activeCount())

Ahora veamos el flujo de control. Una vez que llame al Anfang() Methode, schießen schläfriger_mann () 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.

45642screenshot202021-04-2020at205-57-3920pm-9816829

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

import threading
import time

def sleepy_man(secs):
    drucken('Starting to sleep inside')
    zeit.schlaf(secs)
    drucken('Woke up inside')

x = threading.Thread(Ziel = sleepy_man, Argumente = (4,))
x.start()
drucken(threading.activeCount())
zeit.schlaf(1.2)
drucken('Done')

Die Ausgabe ist wie folgt:

Starting to sleep inside
2
Done
Woke up inside

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

22165screenshot202021-04-2020at206-02-3120pm-3942363

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

import threading
import time

def sleepy_man(secs):
    drucken('Starting to sleep inside - Iteration {}'.Format(5-secs))
    zeit.schlaf(secs)
    drucken('Woke up inside - Iteration {}'.Format(5-secs))

für mich in Reichweite(3):
    x = threading.Thread(Ziel = sleepy_man, Argumente = (5-ich,))
    x.start()

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

In jeder Iteration, activamos un hilo. Tenga en cuenta que pasamos los argumentos 5, 4, 3 ein 1NS, 2Norddakota, Ja 3rd iteración respectivamente. Deswegen, das schläfriger_mann () duerme 5 Sekunden, 4 segundos y 3 segundos respectivamente.

Deswegen, la salida es como se muestra:

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

Deswegen, hemos visto cómo se pueden definir y activar múltiples subprocesos, lo que garantiza una mejor forma de procesamiento, que es muy esencial para las operaciones de E / S pesadas.

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von DataPeaker und werden nach Ermessen des Autors verwendet.

Abonniere unseren Newsletter

Wir senden Ihnen keine SPAM-Mail. Wir hassen es genauso wie du.