KEMBAR78
Python multithreading session 9 - shanmugam | PPT
Python Multithreading
Why Thread
Running several threads is similar to running several different
programs concurrently.
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 sometimes called light-weight processes and they do not
require much memory.
A thread has a beginning, an execution sequence, and a conclusion.
It has an instruction pointer that keeps track of where within its
context it is 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.
Starting a New Thread:
Syntax:
thread.start_new_thread ( function, args[, kwargs] )
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"
Output:
Thread-1: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009
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.
The threading module exposes all the methods of the
thread module and provides some additional 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,
need to do the following:
Define a new subclass of the Thread class.
Override the __init__(self [,args]) method to add
additional arguments.
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 will in turn call run() method.
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:
thread.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()
print "Exiting Main Thread"
Output:
Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2
Synchronizing Threads:
The threading module provided with Python includes a
simple-to-implement locking mechanism that will allow
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
would be used to force threads to run synchronously.
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“
Output:
Starting Thread-1
Starting Thread-2
Thread-1: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread
Python multithreading session 9 - shanmugam

Python multithreading session 9 - shanmugam

  • 1.
  • 2.
    Why Thread Running severalthreads is similar to running several different programs concurrently. 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 sometimes called light-weight processes and they do not require much memory. A thread has a beginning, an execution sequence, and a conclusion. It has an instruction pointer that keeps track of where within its context it is 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.
  • 3.
    Starting a NewThread: Syntax: thread.start_new_thread ( function, args[, kwargs] ) 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()) )
  • 4.
    # Create twothreads 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"
  • 5.
    Output: Thread-1: Thu Jan22 15:42:17 2009 Thread-1: Thu Jan 22 15:42:19 2009 Thread-2: Thu Jan 22 15:42:19 2009 Thread-1: Thu Jan 22 15:42:21 2009 Thread-2: Thu Jan 22 15:42:23 2009 Thread-1: Thu Jan 22 15:42:23 2009 Thread-1: Thu Jan 22 15:42:25 2009 Thread-2: Thu Jan 22 15:42:27 2009 Thread-2: Thu Jan 22 15:42:31 2009 Thread-2: Thu Jan 22 15:42:35 2009
  • 6.
    The Threading Module: Thenewer threading module included with Python 2.4 provides much more powerful, high-level support for threads than the thread module. The threading module exposes all the methods of the thread module and provides some additional methods. The threading module has the Thread class that implements threading.
  • 7.
    The methods providedby 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.
  • 8.
    Creating Thread using ThreadingModule To implement a new thread using the threading module, need to do the following: Define a new subclass of the Thread class. Override the __init__(self [,args]) method to add additional arguments. 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 will in turn call run() method.
  • 9.
    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
  • 10.
    def print_time(threadName, delay,counter): while counter: if exitFlag: thread.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() print "Exiting Main Thread"
  • 11.
    Output: Starting Thread-1 Starting Thread-2 ExitingMain Thread Thread-1: Thu Mar 21 09:10:03 2013 Thread-1: Thu Mar 21 09:10:04 2013 Thread-2: Thu Mar 21 09:10:04 2013 Thread-1: Thu Mar 21 09:10:05 2013 Thread-1: Thu Mar 21 09:10:06 2013 Thread-2: Thu Mar 21 09:10:06 2013 Thread-1: Thu Mar 21 09:10:07 2013 Exiting Thread-1 Thread-2: Thu Mar 21 09:10:08 2013 Thread-2: Thu Mar 21 09:10:10 2013 Thread-2: Thu Mar 21 09:10:12 2013 Exiting Thread-2
  • 12.
    Synchronizing Threads: The threadingmodule provided with Python includes a simple-to-implement locking mechanism that will allow 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 would be used to force threads to run synchronously.
  • 13.
    import threading import time classmyThread (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()
  • 14.
    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()
  • 15.
    # Add threadsto thread list threads.append(thread1) threads.append(thread2) # Wait for all threads to complete for t in threads: t.join() Print "Exiting Main Thread“ Output: Starting Thread-1 Starting Thread-2
  • 16.
    Thread-1: Thu Mar21 09:11:28 2013 Thread-1: Thu Mar 21 09:11:29 2013 Thread-1: Thu Mar 21 09:11:30 2013 Thread-2: Thu Mar 21 09:11:32 2013 Thread-2: Thu Mar 21 09:11:34 2013 Thread-2: Thu Mar 21 09:11:36 2013 Exiting Main Thread