Comunicación entre subprocesos con el método Condition() en Python

Este artículo se basa en cómo usamos el método Condition() para implementar la comunicación entre subprocesos, analicemos este tema a continuación:

Tengamos una breve discusión sobre la comunicación entre subprocesos antes de hablar sobre la implementación de Condition() para la comunicación entre subprocesos. Cuando cualquier subproceso requiera algo de otro, organizarán la comunicación entre ellos y, con esta comunicación, cumplirán con su requisito. Significa que es un proceso de comunicación entre hilos para cualquier tipo de requerimiento. 

Método de condición

Podemos decir que la implementación de la comunicación entre subprocesos utilizando el método condition() es la actualización de ese objeto de evento utilizado para la comunicación entre subprocesos. Aquí Condición representa algún tipo de cambio de estado entre subprocesos como ‘enviar notificación’, ‘recibí notificación’. Vea a continuación cómo se crea el objeto de condición: –     

Sintaxis:

condition_object = threading.condition( )

En este escenario, los subprocesos pueden esperar esa condición y, una vez que esa condición se ejecuta, los subprocesos pueden modificarse de acuerdo con esa condición. En palabras simples, podemos decir que el objeto de condición dio acceso a los hilos para esperar hasta que otro hilo les dé una notificación. El objeto de condición siempre está correlacionado internamente con el concepto de bloqueo (RLock) .

Algunos de los siguientes métodos de la clase Condition los discutimos a continuación:

1. liberar()
2. adquirir()
3. notificar()
4. Espere()
5. notificar a todos()

• Método release(): cuando los subprocesos satisfacen la necesidad del objeto de condición, utilizaremos el método release() que nos ayuda a liberar el objeto de condición de sus tareas y libera repentinamente el bloqueo interno obtenido por los subprocesos.

Syntax: condition_object.release()

• Método de adquisición(): cuando queremos obtener o tomar el control de cualquier objeto de condición para la comunicación entre subprocesos, siempre usamos el método de adquisición() . El método de adquisición() es obligatorio cuando queremos implementar la comunicación entre subprocesos utilizando la clase de condición. Cuando usamos este método, de repente los subprocesos obtienen el sistema de bloqueo interno.

Syntax: condition_object.acquire()

• Método de notificación(): cuando queremos enviar una notificación a un solo hilo que está en estado de espera, siempre usamos el método de notificación() . Aquí, si un subproceso quiere ser objeto de condición de gradación superior, se utiliza la notificación().

Syntax :condition_object.notify()                                      

• Método de espera (tiempo): El método de espera() se puede usar para hacer que un hilo espere hasta que se reciba la notificación y también hasta que finalice el tiempo dado. En palabras simples, podemos decir que el hilo debe esperar hasta que no se complete la ejecución del método de notificación() . Podemos usar el tiempo en él si establecemos un cierto tiempo, entonces la ejecución se detendrá hasta que pase el tiempo, después de eso se ejecutará y aún quedan las instrucciones.

Syntax: condition_object.wait()
Parameter:Time 

•  Método de notificación a todos(): aquí se utiliza el método de notificación a todos () para enviar notificaciones para todos los subprocesos en espera. Si todos los subprocesos están esperando la actualización del objeto de condición, entonces se usará la notificación a todos() .

Syntax: condition_object.notifyAll()

Ahora, tomemos un ejemplo simple para mostrar cómo se usan los métodos de adquisición y liberación y cómo funcionan en todo el programa:

Ejemplo 1:

# code
# import modules
  
import threading 
import time
  
obj1= threading.Condition()
  
  
def task ():
  obj1.acquire()
  print('addition of 1 to 10 ')
  add= 0
  for i in range ( 1 , 11 ):
    add = add+i
  print(add)
  obj1.release()
  print('the condition object is releases now')
    
  
t1 = threading.Thread(target = task)
t1.start()

addition of 1 to 10 
55
the condition object is releases now

En el ejemplo anterior, usamos el método de adquisición() y liberación() que se puede usar para obtener o adquirir el objeto de condición y, después de completar las tareas, libera el objeto de condición. Primero, estamos importando los módulos requeridos, y luego creamos el objeto de condición que es obj1 , luego creamos e iniciamos el subproceso t1 , en la tarea llamada función allí donde usamos el método de adquisición() de estos, obtenemos el objeto de condición y también desde aquí se inicia el bloqueo interno de subprocesos. Después de completar las instrucciones en el último momento, liberamos el objeto de condición y también se libera el bloqueo interno de los subprocesos.

Ejemplo 2:

En este ejemplo, usamos otros métodos para explicar cómo funcionan a través de todo el programa:

# code
  
# import modules
  
import time
from threading import *
import random
  
  
  
class appointment:
    
  def patient(self):
    condition_object.acquire()
    print('patient john waiting for appointment')
    condition_object.wait()   # Thread is in waiting state
    print('successfully got the appointment')
    condition_object.release()
  
  def doctor(self):
    condition_object.acquire()
    print('doctor jarry checking the time for appointment')
    time=0 
    time=random.randint(1,13)
    print('time checked')
    print('oppointed time is {} PM'.format(time))
    condition_object.notify()
    condition_object.release()
  
    
condition_object = Condition()
class_obj=appointment()
  
T1 = Thread(target=class_obj.patient)
  
T2 = Thread(target=class_obj.doctor)
  
T1.start()
  
T2.start()

patient john waiting for appointment
doctor jarry checking the time for appointment
time checked
oppointed time is 4 PM
successfully got the appointment

Este es un ejemplo simple para explicar el uso de la clase Condition() y sus métodos en el enhebrado. Además, aquí usamos un ejemplo de paciente y médico, cómo el paciente y el médico primero adquieren las condiciones y luego cómo se las notifican y, por último, ambos también liberan el objeto de la condición. Comencemos primero, creamos una cita de clase que tenía dos funciones que se nombran como paciente() y médico() y luego creamos dos subprocesos T1 y T2 . Con la ayuda del método de adquisición() , el médico y el paciente adquieren el objeto de condición en su primera declaración, por lo que ambos subprocesos están bloqueados internamente. Ahora el pacientetiene que esperar una cita y fue designado después de la ejecución del método wait() el médico comienza a verificar si la hora que elige está bien para ir a una cita o no y cuando el médico elige la hora, entonces lo notificará al subproceso que está esperando el estado mediante el método de notificación() . A continuación, después del método de notificación() , el paciente recibió tanto la notificación como el producto. Luego, después de todo esto, ambos subprocesos liberan el objeto de condición mediante el método release() y liberaciones de bloqueo internas.