Multithreading : Lock objects - acquire() and release()

Python Multithread

In this chapter, we'll learn how to control access to shared resources. The control is necessary to prevent corruption of data. In other words, to guard against simultaneous access to an object, we need to use a Lock object.

A primitive lock is a synchronization primitive that is not owned by a particular thread when locked. In Python, it is currently the lowest level synchronization primitive available, implemented directly by the _thread extension module.
- https://docs.python.org/3/library/threading.html.

A primitive lock is in one of two states, "locked" or "unlocked". It is created in the unlocked state. It has two basic methods, acquire() and release(). When the state is unlocked, acquire() changes the state to locked and returns immediately. When the state is locked, acquire() blocks until a call to release() in another thread changes it to unlocked, then the acquire() call resets it to locked and returns. The release() method should only be called in the locked state; it changes the state to unlocked and returns immediately. If an attempt is made to release an unlocked lock, a RuntimeError will be raised.

Here is our example code using the Lock object. In the code the worker() function increments a Counter instance, which manages a Lock to prevent two threads from changing its internal state at the same time.

import threading
import time
import logging
import random

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-9s) %(message)s',)
                    
class Counter(object):
    def __init__(self, start = 0):
        self.lock = threading.Lock()
        self.value = start
    def increment(self):
        logging.debug('Waiting for a lock')
        self.lock.acquire()
        try:
            logging.debug('Acquired a lock')
            self.value = self.value + 1
        finally:
            logging.debug('Released a lock')
            self.lock.release()

def worker(c):
    for i in range(2):
        r = random.random()
        logging.debug('Sleeping %0.02f', r)
        time.sleep(r)
        c.increment()
    logging.debug('Done')

if __name__ == '__main__':
    counter = Counter()
    for i in range(2):
        t = threading.Thread(target=worker, args=(counter,))
        t.start()

    logging.debug('Waiting for worker threads')
    main_thread = threading.currentThread()
    for t in threading.enumerate():
        if t is not main_thread:
            t.join()
    logging.debug('Counter: %d', counter.value)

Output:

(Thread-1 ) Sleeping 0.04
(MainThread) Waiting for worker threads
(Thread-2 ) Sleeping 0.11
(Thread-1 ) Waiting for a lock
(Thread-1 ) Acquired a lock
(Thread-1 ) Released a lock
(Thread-1 ) Sleeping 0.30
(Thread-2 ) Waiting for a lock
(Thread-2 ) Acquired a lock
(Thread-2 ) Released a lock
(Thread-2 ) Sleeping 0.27
(Thread-1 ) Waiting for a lock
(Thread-1 ) Acquired a lock
(Thread-1 ) Released a lock
(Thread-1 ) Done
(Thread-2 ) Waiting for a lock
(Thread-2 ) Acquired a lock
(Thread-2 ) Released a lock
(Thread-2 ) Done
(MainThread) Counter: 4

In this example, worker() tries to acquire the lock three separate times, and counts how many attempts it has to make to do so. In the mean time, locker() cycles between holding and releasing the lock, with short sleep in each state used to simulate load.

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-9s) %(message)s',)
                    
def locker(lock):
    logging.debug('Starting')
    while True:
        lock.acquire()
        try:
            logging.debug('Locking')
            time.sleep(1.0)
        finally:
            logging.debug('Not locking')
            lock.release()
        time.sleep(1.0)
    return
                    
def worker(lock):
    logging.debug('Starting')
    num_tries = 0
    num_acquires = 0
    while num_acquires < 3:
        time.sleep(0.5)
        logging.debug('Trying to acquire')
        acquired = lock.acquire(0)
        try:
            num_tries += 1
            if acquired:
                logging.debug('Try #%d : Acquired',  num_tries)
                num_acquires += 1
            else:
                logging.debug('Try #%d : Not acquired', num_tries)
        finally:
            if acquired:
                lock.release()
    logging.debug('Done after %d tries', num_tries)

if __name__ == '__main__':
    lock = threading.Lock()

    locker = threading.Thread(target=locker, args=(lock,), name='Locker')
    locker.setDaemon(True)
    locker.start()

    worker = threading.Thread(target=worker, args=(lock,), name='Worker')
    worker.start()

Output:

(Locker   ) Starting
(Locker   ) Locking
(Worker   ) Starting
(Worker   ) Trying to acquire
(Worker   ) Try #1 : Not acquired
(Locker   ) Not locking
(Worker   ) Trying to acquire
(Worker   ) Try #2 : Acquired
(Worker   ) Trying to acquire
(Worker   ) Try #3 : Acquired
(Locker   ) Locking
(Worker   ) Trying to acquire
(Worker   ) Try #4 : Not acquired
(Worker   ) Trying to acquire
(Worker   ) Try #5 : Not acquired
(Locker   ) Not locking
(Worker   ) Trying to acquire
(Worker   ) Try #6 : Acquired
(Worker   ) Done after 6 tries

Python Multithread