Python: diferencia entre los objetos Lock y Rlock

Un subproceso es una entidad dentro de un proceso que se puede programar para su ejecución. Además, es la unidad de procesamiento más pequeña que se puede realizar en un SO (Sistema Operativo). En palabras simples, un hilo es una secuencia de tales instrucciones dentro de un programa que puede ejecutarse independientemente de otros códigos. Para simplificar, puede suponer que un subproceso es simplemente un subconjunto de un proceso.

Consulte el siguiente artículo para obtener una idea sobre los hilos.

• Multihilo en Python 

Cerraduras

Estos son los primitivos más simples para la sincronización en Python. Hay dos estados de bloqueo, es decir,  bloqueado y desbloqueado . Un bloqueo es una clase en el módulo de subprocesos cuyo objeto se genera en el estado desbloqueado y tiene dos métodos principales, es decir, adquirir() y liberar(). Cuando se llama al método de adquisición(), bloquea la ejecución del bloqueo y bloquea su ejecución hasta que se llama al método de liberación() en algún otro subproceso que lo establece en el estado de desbloqueo. Los bloqueos nos ayudan a acceder de manera eficiente a un recurso compartido en un programa para evitar la corrupción de datos, sigue la exclusión mutua ya que solo un subproceso puede acceder a un recurso en particular a la vez. Veamos el siguiente ejemplo para comprender el uso de las cerraduras: 

# program to illustrate the use of Locks
 
 
import threading
 
 
# creating a Lock object
lock = threading.Lock()
 
# initializing the shared resource
geek = 0
 
def sumOne():
       global geek
    
       # locking the shared resource
       lock.acquire()
       geek = geek + 1
    
       # unlocking the shared resource
       lock.release()
 
def sumTwo():
       global geek
    
       # locking the shared resource
       lock.acquire()
       geek = geek + 2
    
       # unlocking the shared resource
       lock.release()
 
 
# calling the functions
sumOne()
sumTwo()
 
# displaying the value of shared resource
print(geek)

Producción:

3

En el programa anterior, lock es un objeto Lock, la variable global geek es un recurso compartido y las funciones sumOne() y sumTwo() actúan como subprocesos, en la función sumOne(), el recurso compartido geek primero se bloquea y luego se incrementa en 1 y luego se libera geek y en la función sumTwo() primero se bloquea la variable geek y luego se incrementa en 2 y luego se libera geek. Las dos funciones sumOne() y sumTwo() no pueden acceder al recurso compartido geek simultáneamente, solo una de ellas puede acceder al geek de recursos compartidos a la vez.

Rcerraduras

El bloqueo predeterminado no reconoce qué subproceso tiene actualmente el bloqueo. Si cualquier subproceso accede al recurso compartido, otros subprocesos que intenten acceder al recurso compartido se bloquearán incluso si es el mismo subproceso que bloqueó el recurso compartido. El bloqueo de reentrada o RLock se utiliza en estas situaciones para evitar que el bloqueo no deseado acceda al recurso compartido. Si un recurso compartido está en RLock, se puede volver a llamar de forma segura. Varios subprocesos pueden acceder repetidamente al recurso RLocked, aunque todavía funciona correctamente cuando lo llaman diferentes subprocesos. Veamos el siguiente ejemplo para entender el uso de RLocks: 

import threading
 
 
# initializing the shared resource
geek = 0
 
# creating a Lock object
lock = threading.Lock()
 
# the below thread is accessing the
# shared resource
lock.acquire()
geek = geek + 1
 
# This thread will be blocked
lock.acquire()
geek = geek + 2
lock.release()
 
# displaying the value of shared resource
print(geek)

En el programa anterior, dos subprocesos intentan acceder al geek de recursos compartidos simultáneamente, aquí, cuando un subproceso está accediendo actualmente al geek de recursos compartidos, el otro subproceso no podrá acceder a él. Cuando dos o más subprocesos intentan acceder al mismo recurso se impiden entre sí acceder al recurso, esto se conoce como interbloqueo debido a que el programa anterior no genera ningún resultado. Sin embargo, el problema anterior en el programa se puede resolver usando RLock. 

# program to illustrate the use of RLocks
 
# importing the module
import threading
 
# initializing the shared resource
geek = 0
 
# creating an RLock object instead
# of Lock object
lock = threading.RLock()
 
# the below thread is trying to access
# the shared resource
lock.acquire()
geek = geek + 1
 
# the below thread is trying to access
# the shared resource
lock.acquire()
geek = geek + 2
lock.release()
lock.release()
 
# displaying the value of shared resource
print(geek)

Producción:

3

Aquí, no hay prevención no deseada de acceder al geek de recursos compartidos por los subprocesos en el programa. Necesitamos llamar a release() una vez por cada adquisición() de bloqueo de objeto RLock. De los numerosos programas y explicaciones mencionados anteriormente, hay muchas diferencias entre un objeto Lock y un objeto RLock en Python: