Sincronización usando Semaphore en Python

En Lock y RLock , solo se permite ejecutar un subproceso a la vez, pero a veces nuestro requisito es ejecutar un número particular de subprocesos a la vez.   

Supongamos que tenemos que permitir que 10 miembros accedan a la base de datos a la vez y solo 4 miembros pueden acceder a la conexión de red. Para manejar tales tipos de requisitos, no podemos usar el concepto Lock y RLock y aquí deberíamos optar por Semaphore . Semaphore se puede utilizar para limitar el acceso a los recursos compartidos con capacidad limitada. Es una parte avanzada de la sincronización.

Crea un objeto de Semaphore: 

object_name = Semaphore(count)

Aquí ‘recuento’ es el número de subprocesos a los que se permite acceder simultáneamente. El valor predeterminado de conteo es 1.

Cuando un subproceso ejecuta el método adquirir() , el valor de la variable «recuento» se reducirá en 1 y siempre que un subproceso ejecute el método de liberación() , el valor de la variable «recuento» se incrementará en 1. es decir, siempre que adquiera() método se llamará el valor de la variable de recuento se reducirá y cada vez que se llame al método release() se incrementará el valor de la variable «recuento». 

Forma de crear un objeto de Semaphore:  

Caso 1 :                                                                                                                                                                            

object_name.Semaphore()

En este caso, el valor predeterminado de la variable de recuento es 1, por lo que solo se permite el acceso a un subproceso. Es exactamente lo mismo que el concepto de bloqueo .

Caso 2 : 

object_name.Semaphore(n) 

En este caso, n subprocesos pueden acceder a un objeto Semaphore a la vez. Los subprocesos restantes tienen que esperar hasta que se libere el semáforo.

Código ejecutable de Semaphore: 

# importing the modules
from threading import *         
import time        
  
# creating thread instance where count = 3
obj = Semaphore(3)        
  
# creating instance
def display(name):    
    
    # calling acquire method
    obj.acquire()                
    for i in range(5):
        print('Hello, ', end = '')
        time.sleep(1)
        print(name)
          
        # calling release method
        obj.release()    
          
# creating multiple thread 
t1 = Thread(target = display , args = ('Thread-1',))
t2 = Thread(target = display , args = ('Thread-2',))
t3 = Thread(target = display , args = ('Thread-3',))
t4 = Thread(target = display , args = ('Thread-4',))
t5 = Thread(target = display , args = ('Thread-5',))
  
# calling the threads 
t1.start()
t2.start()
t3.start()
t4.start()
t5.start()

Producción:

Aquí, en el ejemplo anterior, primero creamos una instancia de Semaphore Class donde el valor de «recuento» es 3, lo que significa que se puede acceder a Semaphore Object mediante 3 subprocesos a la vez. Ahora hemos creado el método display() que imprimirá el nombre del hilo 5 veces. Ahora creamos 5 subprocesos y ahora cada vez que llamamos al método start() en ese momento, 3 subprocesos pueden acceder a los objetos Semaphore y, por lo tanto, 3 subprocesos pueden ejecutar el método display() a la vez, pero en este ejemplo cada vez que lo ejecutemos lo haremos obtiene un resultado irregular porque 3 subprocesos están ejecutando el método display() a la vez.