Al igual que ejecutar varios programas independientes simultáneamente, ejecutar varios subprocesos simultáneamente también tiene características similares con algunos beneficios adicionales, que son los siguientes:
- Múltiples subprocesos comparten el mismo espacio de datos junto con el subproceso principal dentro de un proceso. Por lo tanto, pueden compartir información fácilmente o pueden comunicarse entre sí a diferencia de si fueran procesos.
- También conocidos como procesos livianos , requieren menos sobrecarga de memoria y, por lo tanto, son más económicos que los procesos.
El subprocesamiento múltiple se define como la capacidad de ejecutar varios subprocesos de forma simultánea o concurrente. Por lo tanto, puede existir más de un subproceso en un solo proceso donde:
- El conjunto de registros y las variables locales de cada subproceso se almacenan en la pila.
- Las variables globales (almacenadas en el montón) y los códigos de programa se comparten entre todos los subprocesos.
Métodos para unir hilos
Al invocar el método join() , el subproceso de llamada se bloquea hasta que el objeto de subproceso (en el que se llama al subproceso) finaliza. Los objetos de hilo pueden terminar bajo cualquiera de las siguientes condiciones:
- O normalmente.
- A través de una excepción mal manejada.
- Hasta que se produzca el tiempo de espera opcional.
Por lo tanto, el método join() indica esperar hasta que termine el hilo. También podemos especificar un valor de tiempo de espera para el método join(). En tal situación, el hilo que llama puede pedirle que se detenga enviando una señal a través de un objeto de evento. El método join() se puede llamar varias veces.
Sintaxis:
object_name.join() OR object_name.join(timeout) where timeout argument is the timeout value.
Ejemplo:
Python3
from threading import Thread
from threading import Event
import time
class Connection(Thread):
StopEvent = 0
def __init__(self,args):
Thread.__init__(self)
self.StopEvent = args
# The run method is overridden to define
# the thread body
def run(self):
for i in range(1,10):
if(self.StopEvent.wait(0)):
print ("Asked to stop")
break;
print("The Child Thread sleep count is %d"%(i))
time.sleep(3)
print ("A Child Thread is exiting")
Stop = Event()
Connection = Connection(Stop)
Connection.start()
print("Main thread is starting to wait for 5 seconds")
Connection.join(5)
print("Main thread says : I cant't wait for more than 5 \
seconds for the child thread;\n Will ask child thread to stop")
# ask(signal) the child thread to stop
Stop.set()
# wait for the child thread to stop
Connection.join()
print("Main thread says : Now I do something else to compensate\
the child thread task and exit")
print("Main thread is exiting")
Producción:
El conteo de inactividad del subproceso secundario es 1
El subproceso principal está comenzando a esperar 5 segundos
El conteo de inactividad del subproceso secundario es 2
El subproceso principal dice: No puedo esperar más de 5 segundos para el subproceso secundario;
Le pedirá al subproceso que se detenga
Pidió que se detuviera
Un subproceso está saliendo
El subproceso principal dice: Ahora hago algo más para compensar la tarea del subproceso secundario y salir
El subproceso principal está saliendo
Puntos para recordar al unir hilos usando join() en Python:
- Se produce un error de tiempo de ejecución cuando se invoca el método join() en el mismo subproceso cuando se llama a join() en el mismo subproceso, lo que da como resultado una condición de interbloqueo.
- Si se llama al método join() en un subproceso que aún no se ha iniciado, se genera un error de tiempo de ejecución.
- Si join() tiene el argumento de tiempo de espera, entonces debería ser un número de coma flotante que represente el tiempo para la operación del subproceso en segundos.
- Si el método join() no tiene argumentos, hasta que el subproceso termine, la operación se bloqueará.
- Como el valor devuelto por join() siempre es Ninguno, siempre debemos usar isAlive() inmediatamente después de join() para verificar si el hilo aún está vivo o no.