The release() method of lock class in Python

The release() method makes the state of a Lock object into unlocked state. Calling release() is important as other threads can acquire the lock to proceed with the execution without undergoing any starvation or dead-lock.

Lock Updated 18 Aug 2025 2 min read

Overview

  • A call to the release() function makes the state of the Lock object into unlocked state.
  • When a Lock object is in unlocked state, a subsequent call to the acquire() succeeds and the block enclosed within the acquire() and release() calls is entered by the thread. Calling the acquire() method makes the lock object into unlocked state.
  • If a thread owning the lock does not call release(), the other threads who invoked acquire() and waiting for their turn to acquire the lock will not succeed. This could lead to starvation and dead-lock scenarios (Owning thread is the one which most recently called the acquire() method and started executing the next statement after the acquire()). In Python, threads are created using the Thread class.
  • The acquire() call can be made through the with statement which ensures release() is called even in case of any exception after the acquire() call is made.

Example

python
# Example Python program that serializes access to

            # a crtitical resource by using a Lock object and

            # calling the acquire() and release() methods

import threading as th

            import time

            import sys

# The counter

            err_num = 0

# Reader thread

            def read(updateEvent, terminate):

                while(terminate.wait(5.0)):

                    if(updateEvent.wait(5.0)):

                        time.sleep(0.01)

                        print("Count value:%d"%err_num)

# Thread function for the increment threads

            def incr(lock, updateEvent, thread_num):

                global err_num

    # Synchronized access to the counter

                with lock:

                    time.sleep(.01)

                    err_num += 1

    updateEvent.set()

                print("Thread %d exiting"%thread_num)

# Print Global Interpreter Lock(GIL) is status

            print("GIL status:")

            print(sys._is_gil_enabled())

# Create a lock

            l = th.Lock()

            threads = []

# Create events

            countUpdate = th.Event()

            countUpdate.clear()

threadsAlive = th.Event()

            threadsAlive.clear()

# Create a reader thread

            r = th.Thread(target = read, args = (countUpdate, threadsAlive))

            r.start()

# Spawn writer threads

            for i in range(0, 10):

                if i == 1:

                    threadsAlive.set()

                    print("At least one thread alive")

                t = th.Thread(target     = incr,

                              args         = (l, countUpdate, i),)

    t.start()

                threads.append(t)

# Wait for the threads to complete

            for t in threads:

                t.join()

            countUpdate.clear()

            threadsAlive.clear()

            r.join()

# Print the final value of the counter

            print("Final count:%d"%err_num)

Output

Output
GIL status:

            False

            At least one thread alive

            Thread 0 exiting

            Thread 1 exiting

            Count value:2

            Thread 2 exiting

            Count value:3

            Count value:4

            Thread 3 exiting

            Count value:5

            Thread 4 exiting

            Count value:5

            Thread 5 exiting

            Count value:7

            Thread 6 exiting

            Count value:7

            Thread 7 exiting

            Count value:8

            Thread 8 exiting

            Thread 9 exiting

            Count value:10

            Final count:10