UNIT 4.

CHAPTER 2 THREADS
Study material for programs explained in video files named as
race_condition,race_condition1 and thread_synchr

Thread Synchronization:
To understand the race condition let us consider one more example. Suppose two railway
reservation clerks from two different places send request for reserving a same seat at the same
time to the server. Two client request are handled by two threads, as two threads act
simultaneously on function that do the reservation, we may get a wrong result such as same seat
is reserved for two person. This is race condition this occurs because two or more thread act on
same function at the same time. To avoid race condition synchronization of thread is needed.
Mean at a time only one thread should act on a method or function.

#pyhton program to illustrate race condition through seat reservation

from threading import *

from time import *

class Railway:

def __init__(self,seats):

self.seats_av=seats

def reserve(self,w):

print("no of seats avialbel",self.seats_av)

if self.seats_av>=w:

name=current_thread().getName()

print("seat is alloted for",name)

self.seats_av-=w

sleep(1)

else:

print("Sorry no seats are avialble")

r=Railway(1)
t1=Thread(target=r.reserve,args=(1,))

t2=Thread(target=r.reserve,args=(1,))

t1.setName("First Person")

t2.setName("Second Person")

t1.start()

t2.start()

output1:

no of seats avialbel 1

seat is alloted for First Person

no of seats avialbel 0

Sorry no seats are avialble

Output2:

no of seats avialbelno of seats avialbel 1

seat is alloted for Second Person

Sorry no seats are avialble

In the above program race condition is occurred. To avoid a race condition threads must be
synchronized. Thread synchronization means when a thread is already acting on object,
preventing any other thread from acting on the same object. Thread synchronization is done
using the following techniques

Using locks

Using semaphores

Thread synchronization using lock:

Locks can be used to lock the object on which the thread is acting. When a thread enters the
object it locks the object and after the execution is completed, it will unlock the object and comes
out of it.
We can create a lock by creating a object of Lock class as

l=Lock()

to lock the current object, we should use acquire() method as

l.acquire()

to unlock or release the object,we can use release() method as

l.release()

#pyhton program to synchronize the threads using lock concept

from threading import *

from time import *

class Railway:

def __init__(self,seats):

self.seats_av=seats

#lock object is created

self.l=Lock()

def reserve(self,w):

#accquire the lock

self.l.acquire()

print("no of seats avialbel",self.seats_av)

if self.seats_av>=w:

name=current_thread().getName()

print("seat is alloted for",name)

self.seats_av-=w

sleep(1)

else:
 print("Sorry no seats are avialble")

#release the lock

self.l.release()

r=Railway(1)

t1=Thread(target=r.reserve,args=(1,))

t2=Thread(target=r.reserve,args=(1,))

t1.setName("First Person")

t2.setName("Second Person")

t1.start()

t2.start()

output1:

no of seats avialbel 1

seat is alloted for First Person

no of seats avialbel 0

Sorry no seats are avialble

Output2:

no of seats avialbel 1

seat is alloted for First Person

no of seats avialbel 0

Sorry no seats are avialble

For every execution of the program we will get the same output

Thread synchronization using semaphore:

A semaphore is an object that provides synchronization based on counter. A semaphore is

created as an object of semaphore class as
l=Semaphore(countervalue) #here the counter value by default is 1

if the counter value is not given, the default value of the counter will be 1. When acquire()
method is called, the counter gets decremented by 1 and when release() is called it is
incremented by 1. These methods are used in the following format:

l.acquire() #makes counter 0 and then lock

#code that is locked by semaphore

l.release() # counter is 0 so unlock and make counter 1

#pyhton program to synchronzie the threads using semaphore concept

from threading import *

from time import *

class Railway:

def __init__(self,seats):

self.seats_av=seats

#create a semaphore object

self.l=Semaphore()

def reserve(self,w):

#acquire a lock and counter becomes 0

self.l.acquire()

print("no of seats avialbel",self.seats_av)

if self.seats_av>=w:

name=current_thread().getName()

print("seat is alloted for",name)

self.seats_av-=w

sleep(1)

else:
 print("Sorry no seats are avialble")

#release a lock and counter becomes 1

self.l.release()

r=Railway(1)

t1=Thread(target=r.reserve,args=(1,))

t2=Thread(target=r.reserve,args=(1,))

t1.setName("First Person")

t2.setName("Second Person")

t1.start()

t2.start()

output1:

no of seats avialbel 1

seat is alloted for First Person

no of seats avialbel 0

Sorry no seats are avialble

Output2:

no of seats avialbel 1

seat is alloted for First Person

no of seats avialbel 0

Sorry no seats are avialble

We get the same output for each execution of the program