Multithreading

Outcomes:
• Different ways of achieving multitasking.
• Difference between Multithreading and
Multiprocessing.
• Create threads in Python using different modules.
• Different methods available in threading
modules.
 Multithreading

Multitasking
• Multitasking is a process of executing multiple
tasks simultaneously.
• We use multitasking to utilize the CPU.
Multitasking can be achieved by two ways:
• Process-based Multitasking(Multiprocessing)
• Thread-based Multitasking(Multithreading)
1) Process-based Multitasking (Multiprocessing)

• Each process have its own address in memory i.e.

each process allocates separate memory area.
• Process is heavyweight.
• Cost of communication between the process is
high.
• Switching from one process to another require
some time for saving and loading registers,
memory maps, updating lists etc.
 2) Thread-based Multitasking (Multithreading)

• Threads share the same address space.

• Thread is lightweight.
• Cost of communication between the thread is
low.
• Multiprocessing and multithreading, both are
used to achieve multitasking.
• Multithreading is mostly used in games,
animation etc.
Multithreading Realtime Examples
1.Background jobs like running application servers like Oracle
application server, Web servers like Tomcat ctc which will come into
action whenever a request comes.
2.Performing some execution while I/O blocked.
3.Gathering information from different web services running in
parallel.
4.Typing MS Word document while listening to music.
5.Games are very good examples of threading. You can use multiple
objects in games like cars, motor bikes, animals, people etc. All these
objects are nothing but just threads that run your game application.
6.Railway ticket reservation system where multiple customers
accessing the server.
 Advantage of Multithreading

• 1) It doesn't block the user because threads are

independent and you can perform multiple
operations at same time.
• 2) You can perform many operations together. so
it saves time.
• 3) Threads are independent so it doesn't affect
other threads if exception occur in a single thread.
• Note: At least one process is required for each
thread.
 What is Thread?

• A thread is a lightweight sub process, a smallest

unit of processing. It is a separate path of
execution.
• Thread is basically a lightweight sub-process, a
smallest unit of processing.
• A thread is an independent flow of execution.
• Threads are independent, if there occurs
exception in one thread, it doesn't affect other
threads. It shares a common memory area.
Multitasking in OS
• As shown in the above figure, thread is
executed inside the process.
• There is context-switching between the
threads.
• There can be multiple processes inside the OS
and one process can have multiple threads.
• Note: At a time one thread is executed only.
 Python 3 - Multithreaded Programming
• Running several threads is similar to running several different
programs concurrently, but with the following benefits −
• Multiple threads within a process share the same data space with the
main thread and can therefore share information or communicate
with each other more easily than if they were separate processes.
• Threads are sometimes called light-weight processes and they do not
require much memory overhead; they are cheaper than processes.
• A thread has a beginning, an execution sequence, and a conclusion. It
has an instruction pointer that keeps track of where within its context
is it currently running.
• It can be pre-empted (interrupted).
• It can temporarily be put on hold (also known as sleeping) while other
threads are running - this is called yielding.
 Types of Threads
There are two different kind of threads −
• kernel thread
• user thread

Kernel Threads are a part of the operating system, while the User-space threads are
not implemented in the kernel.

There are two modules which support the usage of threads in Python3 −
• _thread
• Threading

• The thread module has been "deprecated" (not recommended) for quite a long
time. Users are encouraged to use the threading module instead.

• Hence, in Python 3, the module "thread" is not available anymore. However, it has
been renamed to "_thread" for backwards compatibilities in Python3.
 Starting a New Thread
Syntax:
_thread.start_new_thread ( function, args[, kwargs] )
• This method call enables a fast and efficient way to
create new threads in both Linux and Windows.
• The method call returns immediately and the child
thread starts and calls function with the passed list
of args.
• When the function returns, the thread terminates.
• Here, args is a tuple of arguments; use an empty
tuple to call function without passing any arguments. 
• kwargs is an optional dictionary of keyword
arguments.
 Example
import _thread
import time
 
# Define a function for the thread
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print ("%s: %s" % ( threadName, time.ctime(time.time()) ))
 
# Create two threads as follows
try:
_thread.start_new_thread( print_time, ("Thread-1", 2, ) )
_thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print ("Error: unable to start thread")
 
while 1:
pass
 Sample Output

Thread-1: Fri Feb 19 09:41:39 2016

Thread-2: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:43 2016
Thread-2: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:47 2016
Thread-2: Fri Feb 19 09:41:49 2016
Thread-2: Fri Feb 19 09:41:53 2016
• Program goes in an infinite loop. You will have
to press ctrl-c to stop
• Although it is very effective for low-level
threading, the thread module is very limited
compared to the newer threading module.
 The Threading Module

• The newer threading module included with

Python 2.4 provides much more powerful,
high-level support for threads than the thread
module discussed in the previous section.
• The threading module exposes all the
methods of the thread module and provides
some additional methods −
 Methods available in threading Module
• threading.activeCount() − Returns the number of thread objects that are active.
• threading.currentThread() − Returns the number of thread objects in the caller's
thread control.
• threading.enumerate() − Returns a list of all thread objects that are currently
active.
• In addition to the methods, the threading module has the Thread class that
implements threading. The methods provided by the Thread class are as follows
−
• run() − The run() method is the entry point for a thread.
• start() − The start() method starts a thread by calling the run method.
• join([time]) − The join() waits for threads to terminate.
• isAlive() − The isAlive() method checks whether a thread is still executing.
• getName() − The getName() method returns the name of a thread.
• setName() − The setName() method sets the name of a thread
 Creating Thread Using Threading Module

• To implement a new thread using the threading module,

you have to do the following −
• Define a new subclass of the Thread class.
• Override the __init__(self [,args]) method to add
additional arguments.
• Then, override the run(self [,args]) method to implement
what the thread should do when started.
• Once you have created the new Thread subclass, you can
create an instance of it and then start a new thread by
invoking the start(), which in turn calls the run() method.
Example:
import threading
import time
 
exitFlag = 0
 
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print ("Starting " + self.name)
print_time(self.name, self.counter, 5)
print ("Exiting " + self.name)
 
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
 
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
 
# Start new Threads
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("Exiting Main Thread")
 Sample Output
Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:00:21 2016
Thread-2: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:23 2016
Thread-2: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:25 2016
Exiting Thread-1
Thread-2: Fri Feb 19 10:00:26 2016
Thread-2: Fri Feb 19 10:00:28 2016
Thread-2: Fri Feb 19 10:00:30 2016
Exiting Thread-2
Exiting Main Thread
 Synchronizing Threads

• The threading module provided with Python

includes a simple-to-implement locking mechanism
that allows you to synchronize threads.
• A new lock is created by calling the Lock() method,
which returns the new lock.
• The acquire(blocking) method of the new lock
object is used to force the threads to run
synchronously.
• The optional blocking parameter enables you to
control whether the thread waits to acquire the
lock.
• If blocking is set to 0, the thread returns
immediately with a 0 value if the lock cannot be
acquired and with a 1 if the lock was acquired.
• If blocking is set to 1, the thread blocks and wait
for the lock to be released.
• The release() method of the new lock object is
used to release the lock when it is no longer
required.
import threading
import time
 
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter

def run(self):
print ("Starting " + self.name)
# Get lock to synchronize threads
threadLock.acquire()
print_time(self.name, self.counter, 3)
# Free lock to release next thread
threadLock.release()
 

def print_time(threadName, delay, counter):

while counter:
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1

 
threadLock = threading.Lock()
threads = []
 
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2

# Start new Threads

thread1.start()
thread2.start()
 
# Add threads to thread list
threads.append(thread1)
threads.append(thread2)
 
# Wait for all threads to complete
• for t in threads:
• t.join()
• print ("Exiting Main Thread")