Este artículo cubre los conceptos básicos de subprocesos múltiples en el lenguaje de programación Python. Al igual que multiprocesamiento , el multiproceso es una forma de lograr la multitarea. En subprocesos múltiples, el concepto de hilos se utiliza. Entendamos primero el concepto de hilo en arquitectura de computadores.
¿Qué es un proceso en Python?
En informática, un proceso es una instancia de un programa de computadora que se está ejecutando. Cualquier proceso tiene 3 componentes básicos:
- Un programa ejecutable.
- Los datos asociados que necesita el programa (variables, espacio de trabajo, buffers, etc.)
- El contexto de ejecución del programa (Estado del proceso)
Una introducción al subprocesamiento de Python
A hilo es una entidad dentro de un proceso que se puede programar para su ejecución. Además, es la unidad de procesamiento más pequeña que se puede realizar en un SO (Sistema Operativo). En palabras simples, un hilo es una secuencia de instrucciones dentro de un programa que se puede ejecutar independientemente de otro código. Para simplificar, puedes asumir que un hilo es simplemente un subconjunto de un proceso. Un hilo contiene toda esta información en un Bloque de control de hilo (TCB) :
- Identificador del hilo: Se asigna una identificación única (TID) a cada hilo nuevo
- Puntero de pila: Apunta a la pila del hilo en el proceso. La pila contiene las variables locales bajo el alcance del hilo.
- Contador de programa: un registro que almacena la dirección de la instrucción que actualmente está ejecutando un hilo.
- Estado del hilo: puede estar ejecutándose, listo, esperando, iniciando o listo.
- Conjunto de registros del hilo: registros asignados al hilo para cálculos.
- Puntero del proceso principal: Un puntero al bloque de control de proceso (PCB) del proceso en el que vive el subproceso.
Considere el siguiente diagrama para comprender la relación entre el proceso y su hilo:
Relación entre un proceso y su hilo
Pueden existir varios subprocesos dentro de un proceso donde:
alfabeto a números
- Cada hilo contiene el suyo. conjunto de registro y variables locales (almacenadas en la pila) .
- Todos los hilos de un proceso comparten variables globales (almacenadas en el montón) y el código de programa .
Considere el siguiente diagrama para comprender cómo existen varios subprocesos en la memoria:
Existencia de múltiples hilos en la memoria.
Una introducción al subprocesamiento en Python
subprocesos múltiples Se define como la capacidad de un procesador para ejecutar múltiples subprocesos al mismo tiempo. En una CPU simple de un solo núcleo, esto se logra mediante el cambio frecuente entre subprocesos. Esto se denomina cambio de contexto . En el cambio de contexto, el estado de un subproceso se guarda y el estado de otro subproceso se carga cada vez que se produce una interrupción (debido a E/S o configurada manualmente). El cambio de contexto se produce con tanta frecuencia que todos los hilos parecen estar ejecutándose en paralelo (esto se denomina multitarea ).
Considere el siguiente diagrama en el que un proceso contiene dos subprocesos activos:
subprocesos múltiples
Subprocesos múltiples en Python
En Pitón , el enhebrar El módulo proporciona una API muy simple e intuitiva para generar múltiples subprocesos en un programa. Intentemos comprender el código multiproceso paso a paso.
Paso 1: Módulo de importación
Primero, importe el módulo de subprocesos.
import threading>
Paso 2: Crear un hilo
Para crear un nuevo hilo, creamos un objeto del Hilo clase. Toma el 'objetivo' y los 'argumentos' como parámetros. El objetivo es la función que será ejecutada por el hilo mientras que el argumentos es los argumentos que se pasarán a la función de destino.
t1 = threading.Thread(target, args) t2 = threading.Thread(target, args)>
Paso 3: Iniciar un hilo
Para iniciar un hilo, utilizamos el comenzar() método de la clase Thread.
t1.start() t2.start()>
Etapa 4: Finalizar el hilo Ejecución
Una vez que se inician los subprocesos, el programa actual (puedes considerarlo como un subproceso principal) también continúa ejecutándose. Para detener la ejecución del programa actual hasta que se complete un hilo, usamos el unirse() método.
t1.join() t2.join()>
Como resultado, el programa actual primero esperará a que se complete t1 y luego t2 . Una vez finalizadas, se ejecutan las instrucciones restantes del programa actual.
Ejemplo:
Consideremos un ejemplo sencillo utilizando un módulo de subprocesamiento.
Este código demuestra cómo utilizar el módulo de subprocesos de Python para calcular el cuadrado y el cubo de un número al mismo tiempo. Dos hilos, t1> y t2> , se crean para realizar estos cálculos. Se inician y sus resultados se imprimen en paralelo antes de que el programa imprima ¡Listo! cuando ambos hilos hayan terminado. Threading se utiliza para lograr paralelismo y mejorar el rendimiento del programa cuando se trata de tareas computacionalmente intensivas.
Python3
import> threading> def> print_cube(num):> >print>(>'Cube: {}'> .>format>(num>*> num>*> num))> def> print_square(num):> >print>(>'Square: {}'> .>format>(num>*> num))> if> __name__>=>=>'__main__'>:> >t1>=> threading.Thread(target>=>print_square, args>=>(>10>,))> >t2>=> threading.Thread(target>=>print_cube, args>=>(>10>,))> >t1.start()> >t2.start()> >t1.join()> >t2.join()> >print>(>'Done!'>)> |
>
>
películas indias
Producción:
Square: 100 Cube: 1000 Done!>
Considere el siguiente diagrama para comprender mejor cómo funciona el programa anterior:
subprocesos múltiples
Ejemplo:
En este ejemplo, utilizamos sistema operativo.getpid() función para obtener el ID del proceso actual. Usamos subprocesos.main_thread() función para obtener el objeto del hilo principal. En condiciones normales, el hilo principal es el hilo desde el que se inició el intérprete de Python. nombre El atributo del objeto del hilo se utiliza para obtener el nombre del hilo. Luego usamos el hilo.current_thread() función para obtener el objeto del hilo actual.
cadena concat de java
Considere el programa Python que se muestra a continuación en el que imprimimos el nombre del hilo y el proceso correspondiente para cada tarea.
Este código demuestra cómo utilizar el módulo de subprocesamiento de Python para ejecutar dos tareas simultáneamente. El programa principal inicia dos hilos, t1> y t2> , cada uno responsable de ejecutar una tarea específica. Los subprocesos se ejecutan en paralelo y el código proporciona información sobre el ID del proceso y los nombres de los subprocesos. Elos>El módulo se utiliza para acceder al ID del proceso y al ‘ threading'> El módulo se utiliza para gestionar subprocesos y su ejecución.
Python3
import> threading> import> os> def> task1():> >print>(>'Task 1 assigned to thread: {}'>.>format>(threading.current_thread().name))> >print>(>'ID of process running task 1: {}'>.>format>(os.getpid()))> def> task2():> >print>(>'Task 2 assigned to thread: {}'>.>format>(threading.current_thread().name))> >print>(>'ID of process running task 2: {}'>.>format>(os.getpid()))> if> __name__>=>=> '__main__'>:> >print>(>'ID of process running main program: {}'>.>format>(os.getpid()))> >print>(>'Main thread name: {}'>.>format>(threading.current_thread().name))> >t1>=> threading.Thread(target>=>task1, name>=>'t1'>)> >t2>=> threading.Thread(target>=>task2, name>=>'t2'>)> >t1.start()> >t2.start()> >t1.join()> >t2.join()> |
>
>
Producción:
ID of process running main program: 1141 Main thread name: MainThread Task 1 assigned to thread: t1 ID of process running task 1: 1141 Task 2 assigned to thread: t2 ID of process running task 2: 1141>
El diagrama que figura a continuación aclara el concepto anterior:
subprocesos múltiples
Esta fue una breve introducción al subproceso múltiple en Python. El próximo artículo de esta serie cubre sincronización entre múltiples hilos . Subprocesos múltiples en Python | Conjunto 2 (Sincronización)
Grupo de subprocesos de Python
Un grupo de subprocesos es una colección de subprocesos que se crean con anticipación y se pueden reutilizar para ejecutar múltiples tareas. El módulo concurrent.futures en Python proporciona una clase ThreadPoolExecutor que facilita la creación y administración de un grupo de subprocesos.
En este ejemplo, definimos una función de trabajo que se ejecutará en un hilo. Creamos un ThreadPoolExecutor con un máximo de 2 subprocesos de trabajo. Luego enviamos dos tareas al grupo utilizando el método de envío. El grupo gestiona la ejecución de las tareas en sus subprocesos de trabajo. Usamos el método de apagado para esperar a que se completen todas las tareas antes de que continúe el hilo principal.
El subproceso múltiple puede ayudarlo a hacer que sus programas sean más eficientes y receptivos. Sin embargo, es importante tener cuidado al trabajar con subprocesos para evitar problemas como condiciones de carrera y puntos muertos.
Este código utiliza un grupo de subprocesos creado con concurrent.futures.ThreadPoolExecutor> para ejecutar dos tareas de trabajador al mismo tiempo. El hilo principal espera a que los hilos de trabajo terminen de usar pool.shutdown(wait=True)> . Esto permite un procesamiento paralelo eficiente de tareas en un entorno multiproceso.
Python3
import> concurrent.futures> def> worker():> >print>(>'Worker thread running'>)> pool>=> concurrent.futures.ThreadPoolExecutor(max_workers>=>2>)> pool.submit(worker)> pool.submit(worker)> pool.shutdown(wait>=>True>)> print>(>'Main thread continuing to run'>)> |
>
convertir una fecha en una cadena
>Producción
Worker thread running Worker thread running Main thread continuing to run>