Python Multithreading

Share on facebook
Share on twitter
Share on linkedin
Share on twitter
Share on tumblr

In this Python tutorial, let us discuss Python Multithreading with suitable examples.

Introduction of Python Multithreading

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 interrupted
  • It can temporarily be put on hold while other threads are running – this is called yielding.

Starting a New Thread

We need to call the following method available in the thread module,

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 a 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 the function without passing any arguments. kwargs is an optional dictionary of keyword arguments.

Example code to start a new Thread

import thread
import time
# Define a function for the thread
def print_time( threadName, delay):
  count = 0
  while count < 5:
    count += 1
    print "%s: %s" % ( threadName, time.ctime(time.time()) )
# Create two threads as follows
  thread.start_new_thread( print_time, ("Thread-1", 2, ) )
  thread.start_new_thread( print_time, ("Thread-2", 4, ) )
  print "Error: unable to start thread"
while 1:


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

Multithreaded Priority Queue

The Queue module allows you to create a new queue object that can hold a specific number of items. The following methods to control the Queue such as

  • get() − The get() removes and returns an item from the queue.
  • put() − The put adds an item to a queue.
  • qsize() − The qsize() returns the number of items that are currently in the queue.
  • empty() − The empty( ) returns True if queue is empty; otherwise, False.
  • full() − the full() returns True if queue is full; otherwise, False.

Example for multithreaded priority queue

import Queue
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
  def __init__(self, threadID, name, q):
    self.threadID = threadID = name
    self.q = q
 def run(self):
    print "Starting " +
    process_data(, self.q)
    print "Exiting " +
def process_data(threadName, q):
  while not exitFlag:
     if not workQueue.empty():
       data = q.get()
       print "%s processing %s" % (threadName, data)
threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1
# Create new threads
for tName in threadList:
  thread = myThread(threadID, tName, workQueue)
  threadID += 1
# Fill the queue
for word in nameList:
# Wait for a queue to empty
while not workQueue.empty():
# Notify threads it's time to exit
exitFlag = 1
# Wait for all threads to complete
for t in threads:
print "Exiting Main Thread"


Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

Leave a Comment

Your email address will not be published. Required fields are marked *