Python múltiple

"Dentro de un proceso, una unidad de ejecución se conoce como un hilo. Al mover rápidamente la atención de la CPU entre los hilos, numerosos hilos se pueden ejecutar simultáneamente en un proceso conocido como Multithreading (también llamado Contexting Switching). Los conceptos básicos de Python multithreading se cubrirán en este artículo. Para su ayuda, también proporcionaremos una variedad de ejemplos."

Múltiples lectura en Python

Múltiple leaking es una técnica de roscado utilizada en la programación de Python para ejecutar muchos hilos al mismo tiempo. Además, permite compartir su espacio de datos con los hilos primarios dentro de un proceso, que se comunica y comparten información más fácilmente que los procesos separados. El objetivo de la lectura múltiple es llevar a cabo numerosos procesos simultáneamente, lo que mejora la representación y el rendimiento de la aplicación.

Es un método muy práctico para acelerar y mejorar la funcionalidad de una aplicación. Al usar múltiples lecturas, un programador puede desglosar las tareas de aplicación en trabajos más pequeños y ejecutar múltiples instancias del programa a la vez. Permite que los subprocesos se comuniquen entre sí y compartan recursos del procesador, incluidas la memoria, los archivos y los datos. Además, hace que los usuarios estén más dispuestos a seguir usando un programa incluso cuando una sección está bloqueada o demasiado larga.

Ejemplo 1

Aquí hay un programa simple de Python para múltiples lecturas. Veamos un programa de Python que tiene dos clases, "Python_Demo" y "Python_lesson."Veamos este código de muestra en detalle.

Dos de nuestras clases usan técnicas similares. La salida de la función Ejecutar del objeto de la primera clase cuando se construye e imprime la frase "Python Demo" cuatro veces. La palabra "lección de pitón" aparece cuatro veces cuando repitemos el proceso para la segunda clase.

Clase Python_Demo:
Def Run (Self):
para i en el rango (4):
Imprimir ("Python Demo")
Clase Python_lesson:
Def Run (Self):
para i en el rango (4):
Imprimir ("Lección de Python")
first_obj = python_demo ()
Second_obj = python_lesson ()
First_obj.correr()
Second_obj.correr()

El resultado si ejecutamos este programa es el siguiente. La demostración de Python y la lección de Python se muestran cuatro veces en sucesión, como puede ver. Como resultado, el hilo principal es donde se ejecuta este programa. Cada programa contiene el hilo principal. En este caso, ambas operaciones se llevan a cabo en una secuencia.

Ejemplo 2

Emplearemos el módulo de subproceso de Python como ejemplo. Podríamos entender la necesidad de leer múltiples si consideramos el primer escenario. Eso implica que ambos procedimientos deben usarse simultáneamente. La clase de subprocesos de Python y el paquete de subprocesos se pueden usar para lograr esto. Intentemos pensar en algo. Ahora que la lectura múltiple está presente, el programa de muestra se ha actualizado. Además, cada clase se ejecutó como su propio hilo utilizando la clase de hilo.

También hicimos una diferencia al no llamar directamente al método de ejecución. En cambio, utilizamos el método de inicio, que es básicamente el mecanismo de implementación de subprocesos.

Cuando aplicamos el método de inicio, la función de ejecución se llama instantáneamente en segundo plano. Actualmente ejecutamos el hilo principal de forma predeterminada. Se forman dos hilos infantiles, primer obj y segundo obj cuando se llaman los métodos de inicio.

Desde la importación de enhebrado *
clase Python_Demo (hilo):
Def Run (Self):
para i en el rango (4):
Imprimir ("Python Demo")
clase Python_lesson (hilo):
Def Run (Self):
para i en el rango (4):
Imprimir ("Lección de Python")
first_obj = python_demo ()
Second_obj = python_lesson ()
First_obj.comenzar()
Second_obj.comenzar()

Estos ajustes dan como resultado la salida que se muestra a continuación. Ahora que la aplicación se está ejecutando, se puede ver que está sucediendo múltiples. Podemos ver que varias palabras se agrupan, a pesar del hecho de que "Python Demo" y "Python Less" son dos frases separadas. Esto resultó de una colisión. Ocurre como resultado de dos hilos (First_obj y Second_obj) tratando de ejecutar en la CPU simultáneamente debido a la velocidad excesiva del procesador.

Ejemplo 3

Los programadores en el sistema operativo especifican el tiempo para la ejecución. En este ejemplo, el software lleva a cabo las instrucciones más de una vez en un momento específico.

Podemos evitar esto utilizando el enfoque de sueño para proporcionar un pequeño retraso a nuestro software. Para lograr esto, debemos importar la función de sueño desde el módulo de tiempo para agregar una breve pausa entre la ejecución de los dos hilos. Excepto por la adición de la función de sueño, el código es prácticamente idéntico a los ejemplos de antes.

Observe los módulos necesarios, el roscado y el sueño. Estos módulos se importan primero. La función de sueño se ejecuta en dos clases que luego se construyen. Para imprimir la oración un cierto número de veces en nuestro caso, tres hemos utilizado el bucle for en ambas clases. Para ejecutar la aplicación, invocamos el método Start () después de implementar el enfoque de subproceso. Las líneas finales de código del programa demuestran esto.

Desde la importación de enhebrado *
Desde el tiempo de sueño
clase Python_Demo (hilo):
Def Run (Self):
para i en el rango (3):
Imprimir ("Python Demo")
dormir (1)
clase Python_lesson (hilo):
Def Run (Self):
para i en el rango (3):
Imprimir ("Lección de Python")
dormir (1)
first_obj = python_demo ()
Second_obj = python_lesson ()
First_obj.comenzar()
dormir (0.3)
Second_obj.comenzar()

El resultado ahora demuestra que los hilos se ejecutan simultáneamente.

Ejemplo 4

El módulo de roscado en Python se usa para construir hilos en el siguiente fragmento de código. El hilo principal se ejecuta en el código, y las palabras "Este es el hilo principal" se imprimen. El primer hilo y el segundo hilo son dos hilos recién establecidos y en ejecución. Hay una transición de contexto, y el primer hilo comienza a ejecutarse.

El primer hilo va a dormir después de las primeras cuatro iteraciones, mientras que el segundo hilo comienza a funcionar y se completa justo a tiempo para el siguiente cambio de contexto.

La CPU ahora está bajo el control del hilo principal, que escribe "el hilo principal nuevamente!"

El segundo hilo se reanuda su ejecución después de otro cambio de contexto y se completa. El hilo principal ya no puede ejecutar más instrucciones; De ahí el programa termina.

Importar subprocesos como TD
Tiempo de importación como t
Def print_welcome ()::
Para I en el rango (5):
Si i == 4:
T.dormir (2)
Imprimir ("Bienvenido")
Def print_integers (n):
para i en el rango (n+1):
Imprimir (i)
imprimir ("Este es el hilo principal.")
First_thread = TD.Thread (target = print_welcome, args = ())
Second_thread = TD.Thread (Target = Print_Integers, Args = (10,)))
First_Thread.comenzar()
Second_thread.comenzar()
imprimir ("hilo principal nuevamente!")

Puede ver la salida en esta sección, donde el hilo principal se ejecuta primero, y el mensaje se repite según sea necesario. Después de la ejecución del segundo hilo, que mostró los números, el software volvió al primer hilo y llevó a cabo la función que muestra la palabra "Bienvenido."

Conclusión

El tema de este artículo fue Python Multithreading. Al cambiar rápidamente entre hilos utilizando una CPU, Multithreading es una técnica de roscado utilizada en la programación de Python para ejecutar muchos hilos simultáneamente. Además, permite compartir su espacio de datos con los hilos primarios dentro de un proceso, que se comunica y comparten información más fácilmente que los procesos separados. El objetivo de la lectura múltiple es llevar a cabo numerosos procesos simultáneamente.