{"id":1710,"date":"2020-12-17T09:22:17","date_gmt":"2020-12-17T09:22:17","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=1710"},"modified":"2023-06-03T12:16:06","modified_gmt":"2023-06-03T12:16:06","slug":"python-threading-lock","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-concurrency\/python-threading-lock\/","title":{"rendered":"How to use the Python Threading Lock to Prevent Race Conditions"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about race conditions and how to use the Python threading Lock object to prevent them.<\/p>\n\n\n\n

What is a race condition #<\/a><\/h2>\n\n\n\n

A race condition occurs when two or more threads<\/a> try to access a shared variable simultaneously, leading to unpredictable outcomes.<\/p>\n\n\n\n

In this scenario, the first thread reads the value from the shared variable. At the same time, the second thread also reads the value from the same shared variable.<\/p>\n\n\n\n

Then both threads attempt to change the value of the shared variable. since the updates occur simultaneously, it creates a race to determine which thread’s modification is preserved.<\/p>\n\n\n\n

The final value of the shared variable depends on which thread completes its update last. Whatever thread that changes the value last will win the race. <\/p>\n\n\n\n

Race condition example #<\/a><\/h2>\n\n\n\n

The following example illustrates a race condition:<\/p>\n\n\n

from<\/span> threading import<\/span> Thread\nfrom<\/span> time import<\/span> sleep\n\n\ncounter = 0<\/span>\n\ndef<\/span> increase<\/span>(by)<\/span>:<\/span>\n    global<\/span> counter\n\n    local_counter = counter\n    local_counter += by\n\n    sleep(0.1<\/span>)\n\n    counter = local_counter\n    print(f'counter={counter}<\/span>'<\/span>)\n\n\n# create threads<\/span>\nt1 = Thread(target=increase, args=(10<\/span>,))\nt2 = Thread(target=increase, args=(20<\/span>,))\n\n# start the threads<\/span>\nt1.start()\nt2.start()\n\n\n# wait for the threads to complete<\/span>\nt1.join()\nt2.join()\n\n\nprint(f'The final counter is {counter}<\/span>'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this program, both threads try to modify the value of the counter<\/code> variable at the same time. The value of the counter<\/code> variable depends on which thread completes last.<\/p>\n\n\n\n
If the thread t1<\/code> completes before the thread t2<\/code>, you’ll see the following output:<\/p>\n\n\n
counter=10<\/span>\ncounter=20<\/span>\nThe counter is<\/span> 20<\/span>   <\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Otherwise, you’ll see the following output:<\/p>\n\n\n
counter=20<\/span>\ncounter=10<\/span>\nThe final counter is<\/span> 10<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, import Thread<\/code> class from the threading<\/code> module and the sleep()<\/code> function from the time<\/code> module:<\/p>\n\n\n
from<\/span> threading import<\/span> Thread\nfrom<\/span> time import<\/span> sleep<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, define a global variable called counter<\/code> whose value is zero:<\/p>\n\n\n
counter = 0<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, define a function that increases the value of the counter<\/code> variable by a number:<\/p>\n\n\n
def<\/span> increase<\/span>(by)<\/span>:<\/span>\n    global<\/span> counter\n\n    local_counter = counter\n    local_counter += by\n\n    sleep(0.1<\/span>)\n\n    counter = local_counter\n    print(f'counter={counter}<\/span>'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Fourth, create two threads. The first thread increases the counter<\/code> by 10 while the second thread increases the counter<\/code> by 20:<\/p>\n\n\n
t1 = Thread(target=increase, args=(10<\/span>,))\nt2 = Thread(target=increase, args=(20<\/span>,))<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Fifth, start the threads:<\/p>\n\n\n
t1.start()\nt2.start()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Sixth, from the main thread, wait for the threads t1 and t2 to complete:<\/p>\n\n\n
t1.join()\nt2.join()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Finally, show the final value of the counter<\/code> variable:<\/p>\n\n\n
print(f'The final counter is {counter}<\/span>'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Using a threading lock to prevent the race condition #<\/a><\/h2>\n\n\n\n
To prevent race conditions, you can use a threading lock.<\/p>\n\n\n\n
A threading lock is a synchronization primitive that provides exclusive access to a shared resource in a multithreaded application. A thread lock is also known as a mutex<\/strong> which is short for mutual exclusion.<\/p>\n\n\n\n
Typically, a threading lock has two states: locked and unlocked. When a thread acquires a lock, the lock enters the locked state. The thread can have exclusive access to the shared resource.<\/p>\n\n\n\n
Other threads that attempt to acquire the lock while it is locked will be blocked and wait until the lock is released.<\/p>\n\n\n\n
In Python, you can use the Lock<\/code> class from the threading<\/a><\/code> module to create a lock object:<\/p>\n\n\n\n
First, create an instance the Lock<\/code> class:<\/p>\n\n\n
lock = Lock()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
By default, the lock is unlocked until a thread acquires it.<\/p>\n\n\n\n
Second, acquire a lock by calling the acquire()<\/code> method:<\/p>\n\n\n
lock.acquire()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, release the lock once the thread completes changing the shared variable:<\/p>\n\n\n
lock.release()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following example shows how to use the Lock<\/code> object to prevent the race condition in the previous program:<\/p>\n\n\n
from<\/span> threading import<\/span> Thread, Lock\nfrom<\/span> time import<\/span> sleep\n\n\ncounter = 0<\/span>\n\n\ndef<\/span> increase<\/span>(by, lock)<\/span>:<\/span>\n    global<\/span> counter\n\n    lock.acquire()\n\n    local_counter = counter\n    local_counter += by\n\n    sleep(0.1<\/span>)\n\n    counter = local_counter\n    print(f'counter={counter}<\/span>'<\/span>)\n\n    lock.release()\n\n\nlock = Lock()\n\n# create threads<\/span>\nt1 = Thread(target=increase, args=(10<\/span>, lock))\nt2 = Thread(target=increase, args=(20<\/span>, lock))\n\n# start the threads<\/span>\nt1.start()\nt2.start()\n\n\n# wait for the threads to complete<\/span>\nt1.join()\nt2.join()\n\n\nprint(f'The final counter is {counter}<\/span>'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
counter=10<\/span>\ncounter=30<\/span>\nThe final counter is<\/span> 30<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n