Home » Python » Python Reference » Python Lock Class

Python Lock acquire() Method with Example

Python Lock.acquire() Method: In this tutorial, we will learn about the acquire() method of Lock Class in Python with its usage, syntax, and examples. By Hritika Rajput Last updated : April 24, 2023

Python Lock.acquire() Method

The Lock.acquire() is an inbuilt method of the Lock class of the threading module, it is used to acquire a lock, either blocking or non-blocking. When it is invoked without arguments, it blocks the calling thread until the lock is unlocked by the thread using it currently.

Module

The following module is required to use acquire() method:

from threading import Lock 

Class

The following class is required to use acquire() method:

from threading import Lock 

Syntax

The following is the syntax of acquire() method:

acquire( blocking=True, timeout=-1)

Parameter(s)

The following are the parameter(s):

• blocking: It is an optional parameter, which works as a blocking flag. If it is set to True, the calling thread will be blocked if some other thread is holding the flag and once that lock is released, then the calling thread will acquire the lock and return True. If it is set to False, it will not block the thread if the lock is already acquired by some other thread, and will return False. Its default value is True.
• timeout: It is an optional parameter, which specifies the number of seconds for which the calling thread will be blocked if some other method is acquiring the lock currently. Its default value is -1 which indicates that the thread will be blocked for an indefinite time till it acquires the lock.

Note: It is forbidden to specify a timeout when blocking is false.

Return Value

The return type of this method is <class 'bool'>. The function is used to acquire a lock while implementing multithreading and returns True is lock was successfully acquired else returns False.

Example of Lock.acquire() Method in Python

# Python program to show
# the use of acquire() method in Lock class
import threading
import random
                    
class shared(object):
  
    def __init__(self, x = 0):
        # Created a Lock object
        self.lock = threading.Lock()
        self.incr = x
        
        # Increment function for the thread
    def incrementcounter(self):
        print("Waiting for the lock to be unlocked")
        # Lock acquired by the current thread
        self.lock.acquire()
        try:
            print('Lock acquired, current counter value: ', self.incr)
            self.incr = self.incr + 1
        finally:
            print('Lock released, current counter value: ', self.incr)
            # Lock released by the given thread
            self.lock.release()

def helper_thread(c):
    # Getting a random integer between 1 to 3
    r = random.randint(1,3)
    print("Random value selected:", r)
    for i in range(r):
      c.incrementcounter()
    print('Finished', str(threading.current_thread().getName()))
    print()

if __name__ == '__main__':
    obj = shared()

    thread1 = threading.Thread(target=helper_thread, args=(obj,))
    thread1.start()
    
    thread2 = threading.Thread(target=helper_thread, args=(obj,))
    thread2.start()

    thread1.join()
    thread2.join()
    
    print('Final counter value:', obj.incr)

Output

Random value selected: 1
Waiting for the lock to be unlocked
Lock acquired, current counter value:  0
Lock released, current counter value:  1
Finished Thread-1

Random value selected: 2
Waiting for the lock to be unlocked
Lock acquired, current counter value:  1
Lock released, current counter value:  2
Waiting for the lock to be unlocked
Lock acquired, current counter value:  2
Lock released, current counter value:  3
Finished Thread-2

Final counter value: 3