Implementar la comunicación entre subprocesos con el método Event() en Python

Aquí comenzaremos desde lo básico de lo que es la comunicación entre subprocesos. La comunicación entre subprocesos es el proceso de comunicación de requisitos entre uno y otro subproceso. En palabras simples, a veces se puede requerir que un subproceso se comunique con otro subproceso según los requisitos. Esto se considera comunicación entre subprocesos . 

Método Event(): aquí hablamos sobre el método Event() , el objeto Event se considera o recomienda como el proceso o sistema de comunicación más simple entre cualquier subproceso. Este sistema funciona en dos condiciones en las que el objeto Evento está Habilitado significa set() o deshabilitado significa clear() .  

Sintaxis:

evento_objeto = subprocesamiento.Evento()

En el Evento Interno se gestiona el proceso que se trabajará internamente y se puede Establecer ( habilitado ) o Borrar ( deshabilitado ) utilizando los métodos sobre objetos de evento. Si los subprocesos deben establecerse, todos los subprocesos se ejecutarán, pero si los subprocesos deben borrarse, generalmente todos los subprocesos se vuelven a esperar la ejecución.

Ejemplo :

 Tomamos un ejemplo para explicar cómo se usa el método de evento en la implementación de la comunicación entre subprocesos:

#import modules
import threading
import time
  
if __name__ == '__main__':
  
    # initializing the event object
    event_object = threading.Event()
  
# defining task
def task():
    
    print("\nStarted thread but waiting for event...")
    event_set = event_object.wait(4)
      
    if event_set:
        print("\nreceived and releasing thread")
    else:
        print("\ntime is gone...")
  
  
# assigning task
thread1 = threading.Thread(target=task)
  
# starting thread
thread1.start()
  
time.sleep(3)
event_object.set()
print("\nsetting of event is done")

Producción:

En el siguiente programa anterior en el que creamos el objeto de evento, y luego creamos un subproceso y lo iniciamos, ahora el subproceso se configura como objeto de evento con el método set() y en la función task() donde el subproceso está esperando el Si el evento se establece en el subproceso, se ejecutará aquí la siguiente instrucción, si no se configuró, el programa finaliza y todavía hay una instrucción para ejecutar.

Aquí hay algunos métodos generales que se utilizan en la clase de evento: –

•  Método clear(): Este método es completamente opuesto al método set() , pero este método también actúa como un cambiador de condiciones si la condición se vuelve Falsa , entonces qué subproceso no se está ejecutando o ya está en espera, por lo que todavía está esperando. estado y no continuar allí la ejecución.
• Método set(): en el método set() lo usamos como un cambiador de condición entre subprocesos donde si la condición es verdadera , entonces hay muchos subprocesos que estaban esperando el estado en el que se encuentran para continuar con su ejecución.
• Método isSet(): Este método isSet() tiene el significado que su nombre sugiere es set , este método simplifica que el siguiente evento que hemos creado se establezca o no .
• Método wait( time ): Para describir el método wait() en palabras simples, podemos decir que el hilo espera hasta que no se realiza la ejecución del método set() . Podemos usar el tiempo en él si establecemos un cierto tiempo, luego la ejecución se detendrá hasta que el tiempo termine, después de eso se ejecutará y aún queda el set() de un evento.

Aquí tomaremos un ejemplo simple para explicar cómo se utilizan los métodos anteriores a lo largo de todo el programa:

# import time module
import time
  
# import threading module
import threading
  
class product:
    
  def buyer(self):
    print('John consumer is wait for product')   
    print('...............')
    event_object.wait()    
    print('got product')       
    
  def seller(self):   
    time.sleep(5)
    print('Tom producer producing items')  
    print('tom goes to retailer')
    event_object.wait()
      
  def retailer(self):
    time.sleep(10)
    print('retailer found that product and directly send to buyer')
    event_object.set()
            
  
# class object      
class_obj = product()
  
# setting event object
if __name__=='__main__':
  event_object = threading.Event()
  
# creating  threads
T1 = threading.Thread(target=class_obj.buyer)
T2 = threading.Thread(target=class_obj.seller)
T3 = threading.Thread(target=class_obj.retailer)
  
# starting threads
T1.start()
T2.start()
T3.start()

Producción:

Este es un ejemplo simple para explicar el uso de la clase event() y sus métodos en la comunicación entre subprocesos. Aquí usamos un ejemplo de comprador-vendedor y minorista, primero, importamos dos módulos que son el módulo de subprocesamiento y el módulo de tiempo, luego creamos un producto de clase en el que tiene la primera función que es el comprador() que tiene varios instrucciones. En el primer subproceso T3 se ejecutará para la función minorista() , pero el T3 esperará 10 segundos debido al temporizador después de que este T2 se ejecute, pero lo mismo aquí T2 también tiene que esperar 5 segundos, después de eso ahora T1 va para ejecutar la función de comprador() en la función de comprador cuando se ejecuta el método de espera() y luego el subproceso T1tiene que esperar hasta que se establezca un evento(), ahora T2 ejecutará sus instrucciones donde también tiene el método wait() cuando se ejecuta wait() , luego el subproceso T2 detiene su ejecución hasta que se llama al método set() . Ahora es el momento para que el subproceso T3 en este método set() se llame, lo que libera a todos los subprocesos en espera del estado de espera y aquellos subprocesos como T2 y T1 continúan su ejecución.