Subprocesos del demonio de Python

Los subprocesos que siempre se ejecutarán en segundo plano y que brindan soporte a subprocesos principales o no daemon, esos subprocesos que se ejecutan en segundo plano se consideran subprocesos daemon. El subproceso Daemon no bloquea la salida del subproceso principal y continúa ejecutándose en segundo plano. Este artículo se basa en subprocesos en python, aquí discutimos el subproceso daemon con ejemplos.

Hay uno de los mejores ejemplos de un subproceso daemon es Garbage Collector porque asumimos que el subproceso principal se está ejecutando o en ejecución, en ese momento ocurre cualquier problema de memoria e inmediatamente la máquina virtual Python (PVM) ejecutará Garbage Collector . The Garbage Collector se ejecutará en segundo plano y destruirá todos los objetos inútiles y luego se proporcionará memoria libre de forma predeterminada, una vez que haya memoria libre disponible, el hilo principal se ejecutará sin ningún problema.

Hilo normal aprendiendo el flujo de hilo no daemon

Este ejemplo simplifica el flujo de un subproceso que no es demonio en el que hemos creado una función de nombre thread_1() que tiene algunas líneas de instrucciones para ejecutar que revelan cómo se ejecuta el subproceso que no es demonio cuando finaliza el subproceso principal. A continuación, hemos creado el subproceso T de la función subproceso_1() que actualmente se considera un subproceso no activo, ahora iniciamos el subproceso T y también hemos detenido temporalmente la ejecución del subproceso principal durante 5 segundos. De tiempo, entre estos 5 seg. El hilo T continúa su ejecución y cuando el hilo principal se va a ejecutar después de 5 segundos. Donde deja de funcionar pero hay un hilo Ttodavía está en ejecución porque es un subproceso que no es un demonio y ejecuta su instrucción hasta su finalización. 

A continuación se muestra la implementación:

# import module
from threading import *
import time
 
# creating a function
def thread_1():                
  for i in range(5):
    print('this is non-daemon thread')
    time.sleep(2)
 
# creating a thread T
T = Thread(target=thread_1)
 
# starting of thread T
T.start()     
 
# main thread stop execution till 5 sec.
time.sleep(5)                  
print('main Thread execution')

Producción: 

this is non-daemon thread
this is non-daemon thread
this is non-daemon thread
main Thread execution
this is non-daemon thread
this is non-daemon thread

El flujo de subprocesos daemon sobre subprocesos no daemon

Este es un ejemplo para mostrar cómo se comportan los subprocesos daemon sobre los subprocesos no daemon durante la ejecución del programa. Ya vemos en el ejemplo anterior cómo el subproceso que no es demonio completa su ejecución después de la finalización del subproceso principal, pero aquí hay algo diferente a eso. En este ejemplo, hemos creado una función thread_1() y el subproceso T como en el ejemplo anterior, pero aquí, después de la creación del subproceso T , usamos el método setDaemon() para cambiar la naturaleza no demoníaca del subproceso T a la naturaleza del demonio, luego inicia el hilo T y detiene temporalmente la ejecución del hilo principal. Aquí está el giro cuando el subproceso principal completa su ejecución y termina luego el subproceso Ttambién termina porque este es un subproceso daemon, donde el subproceso daemon termina su ejecución cuando finaliza el subproceso principal, su trabajo es admitir el subproceso principal si no queda ningún subproceso principal ¿por qué el subproceso daemon se ejecuta allí también terminan la ejecución de instrucciones? queda

A continuación se muestra la implementación: 

# import modules
from threading import *
import time
 
# creating a function
def thread_1():                     
  for i in range(5):
    print('this is thread T')
    time.sleep(3)
 
# creating a thread
T = Thread(target = thread_1)
 
# change T to daemon
T.setDaemon(True)                  
 
# starting of Thread T
T.start()                          
time.sleep(5)
print('this is Main Thread') 

Producción:

this is thread T
this is thread T
this is Main Thread

Métodos para verificar si el subproceso es demonio o no demonio

Hay un método y una propiedad para verificar la naturaleza del siguiente hilo:

• esDaemon( )
• demonio

Ejemplo 1: Programa para explicar los métodos isDaemon() y daemon.

Este es un ejemplo simple para explicar cómo verificamos la naturaleza o el estado del siguiente hilo, en este ejemplo, verificamos la naturaleza del hilo principal usando isDaemon() y el método daemon . Aquí usamos el método current_thread() que simplifica qué subproceso se está ejecutando actualmente, y lo usamos con isDaemon() y el método daemon para verificar la naturaleza o el estado del subproceso actual. El resultado de este código es Falso y Falso porque subproceso_actual es el subproceso principal y siempre es un subproceso no demonio.

# import module
from threading import *
 
print(current_thread().isDaemon())
        
print(current_thread().daemon)

Producción:

False
False

Ejemplo 2: 

En este ejemplo, hemos creado una función para verificar si el subproceso es un demonio o no, luego creamos un nuevo subproceso subproceso_1 que actualmente es un subproceso no demonio y un subproceso no activo, luego verificamos el estado o la naturaleza del subproceso, la salida se vuelve Falsa después de eso, comenzamos un hilo ahora el hilo se convierte en un hilo activo nuevamente, verificamos su estado y la salida nuevamente es Falsa, todo esto significa que no el hilo principal no es un demonio, sino que también otro hilo creado no es un demonio.

# import module
from threading import *
 
def fun_daemon():
  print("GFG")
   
thread_1 = Thread(target=fun_daemon)
print(thread_1.isDaemon())
thread_1.start()
print(thread_1.daemon)

Producción:

False
GFG
False

Cambiar de no demonio a demonio

Como vimos anteriormente cómo verificar si el siguiente subproceso es un demonio o no demonio, aquí aprendemos cómo el siguiente subproceso no demonio se puede cambiar a demonio.

 Un setDaemon() es el método que se usa para cambiar la naturaleza no daemon de un subproceso dado a la naturaleza daemon. El método setDaemon() toma solo un parámetro que es un valor booleano ( Verdadero o Falso ). 

Sintaxis: Thread_name.setDaemon()    

# Aquí Thread_name se refiere al nombre del hilo que ha utilizado.     

Parámetro: ( Verdadero o Falso )  

• si es Verdadero, marca este hilo como un hilo daemon
• si es False, marca este subproceso como un subproceso no daemon.

Ejemplo:

# import module
from threading import *
 
def fun():
    print("Geeks For Geeks")
 
T = Thread(target = fun)
 
print("GFG")
print(T.isDaemon())
 
# set thread as Daemon
T.setDaemon(True) 
 
# check status
print(T.isDaemon())
T.start()

Producción:

GFG
False
True
Geeks For Geeks

Explicación:

En el ejemplo anterior, primero importamos una biblioteca de subprocesos , luego definimos una nueva función fun() en el siguiente punto, creamos una nueva variable de subprocesos T.  Actualmente, T es un subproceso no activo, no ejecutamos start() método aún, aquí verificaremos el estado del subproceso T y la salida llega a ser Falsa a continuación, usamos el método setDaemon() para cambiar la naturaleza del subproceso T después de usar el método nuevamente verificaremos el estado del siguiente subproceso en este la salida de tiempo será True . 

Cambiar hilo principal a hilo daemon

Si queremos cambiar el subproceso principal que siempre es de naturaleza no daemon a naturaleza daemon, obtendremos un RuntimeError porque cuando el programa se inicia en un momento en que también se inicia el subproceso principal, el subproceso principal es un subproceso activo y el subproceso activo thread no está configurado para el daemon.

Ejemplo:

# import module
from threading import *
 
print(current_thread().setDaemon(True))

Producción: 

RuntimeError: cannot set daemon status of active thread