Python - Threading Quick Revision

This section provides a quick revision of all important concepts covered in Python Multi Threading.

We have learned about:

• Multi Tasking
• Process Based Multi Tasking
• Thread Based Multi Tasking
• Applications of Multi Threading
• Python threading module
• Main Thread
• Creating Threads
• Thread methods
• Thread information
• Daemon Threads
• Synchronization
• Lock
• RLock
• Semaphore
• BoundedSemaphore
• Inter Thread Communication
• Event
• Condition
• Queue

Multi Tasking means executing several tasks simultaneously.

There are two types of Multi Tasking:

1. Process Based Multi Tasking
2. Thread Based Multi Tasking

                 Multi Tasking
                      │
            ┌─────────┴─────────┐
            │                   │
            ▼                   ▼
     Process Based         Thread Based
      Multi Tasking         Multi Tasking

Simple Definition:

Executing several tasks simultaneously is called Multi Tasking.

In Process Based Multi Tasking, every task runs as a separate process.

It is best suitable at the Operating System level.

Examples:

• Editing a Python program
• Listening to MP3 songs
• Downloading a file

All these tasks execute independently.

Operating System
      │
      ├── Process 1 → Edit Python Program
      │
      ├── Process 2 → Play MP3 Song
      │
      └── Process 3 → Download File

In Thread Based Multi Tasking, multiple independent parts of the same program execute simultaneously.

Each independent part is called a Thread.

Thread Based Multi Tasking is best suitable at the program level.

              One Program
                  │
        ┌─────────┼─────────┐
        │         │         │
        ▼         ▼         ▼
     Thread-1  Thread-2  Thread-3

Simple Definition:

A Thread is an independent part of the same program.

Important applications of Multi Threading include:

• Multimedia Graphics
• Animations
• Video Games
• Web Servers
• Application Servers

Multi Threading
      │
      ├── Multimedia Graphics
      ├── Animations
      ├── Video Games
      ├── Web Servers
      └── Application Servers

Python provides the built-in module:

threading

to develop multi-threaded applications.

We can import it using:

import threading

or:

from threading import *

Every Python program contains one default Thread.

It is called:

MainThread

The Main Thread starts automatically when the Python program starts.

Python Program Starts
        │
        ▼
    MainThread
        │
        ▼
Execute Program

Python supports three ways to create Threads:

1. Creating a Thread without using any class
2. Creating a Thread by extending the Thread class
3. Using a normal class object as Thread target

Program Starts
      │
      ▼
MainThread
      │
      ▼
Create Thread Object
      │
      ▼
t.start()
      │
      ▼
Child Thread Starts
      │
      ├──────────► display()
      │
      ▼
Main Thread Continues

The exact execution order can vary because Thread scheduling is not predictable.

The important Thread methods covered in this tutorial are:

• start()
• run()
• join()

The join() method makes one Thread wait until another Thread completes its execution.

t.join()

We can also specify a waiting time:

t.join(seconds)

In this case, the calling Thread waits for the specified amount of time or until the target Thread completes.

Every Thread has a name.

The tutorial covers the name property.

Every Thread receives a default name, which can be changed.

t.name

t.name = "MyThread"

Every Thread has a unique identification number.

It can be accessed using:

ident

Example:

t.ident

This provides the identification number associated with the Thread.

active_count() returns the number of currently active Threads.

active_count()

Conceptually:

Currently Running Threads

MainThread
Thread-1
Thread-2

active_count()
      │
      ▼
      3

enumerate() returns a list containing all currently active Thread objects.

enumerate()

It can be used when we want information about all active Threads.

is_alive() checks whether a Thread is still executing.

t.is_alive()

Conceptually:

Thread Running
     │
     ▼
   True


Thread Completed
     │
     ▼
   False

Daemon Threads run in the background and provide support to Non-Daemon Threads.

Example:

• Garbage Collector

When the last Non-Daemon Thread terminates, the remaining Daemon Threads terminate automatically.

Main Thread
Non-Daemon Threads
       │
       ▼
All Complete
       │
       ▼
Remaining Daemon Threads
Terminate Automatically

Synchronization is used to avoid data inconsistency when multiple Threads access shared resources.

The synchronization techniques covered are:

• Lock
• RLock
• Semaphore

Synchronization
      │
      ├── Lock
      ├── RLock
      └── Semaphore

Simple Definition:

Synchronization controls concurrent access to shared resources so that data inconsistency can be avoided.

Without proper synchronization, multiple Threads may access the same shared resource simultaneously.

Thread-1 ─────┐
              │
              ▼
        Shared Resource
              ▲
              │
Thread-2 ─────┘

Possible Problem
      │
      ▼
Data Inconsistency

Synchronization controls access to the shared resource.

A Lock allows only one Thread at a time to enter the protected section.

Important methods:

acquire()
release()

Basic pattern:

l.acquire()

# Critical Section

l.release()

Thread-1
   │
   ▼
Acquire Lock
   │
   ▼
Critical Section
   │
   ▼
Release Lock
   │
   ▼
Next Waiting Thread

RLock means Reentrant Lock.

The same Thread can acquire an RLock multiple times.

This is useful for:

• Recursive functions
• Nested resource access

Same Thread
    │
    ├── acquire()
    ├── acquire()
    ├── acquire()
    │
    ▼
Allowed with RLock

The Thread must release the RLock appropriately for its acquisitions.

A Semaphore allows a fixed number of Threads to access a protected section simultaneously.

Example:

s = Semaphore(3)

Here, up to three Threads can acquire the Semaphore at the same time.

Semaphore(3)

Thread-1 ──► Allowed
Thread-2 ──► Allowed
Thread-3 ──► Allowed
Thread-4 ──► Wait
Thread-5 ──► Wait

BoundedSemaphore is similar to Semaphore.

The important difference is that it prevents the Semaphore counter from being released beyond its initial bound.

The tutorial demonstrates this with extra release() calls.

s = BoundedSemaphore(2)

s.acquire()
s.acquire()

s.release()
s.release()

# Extra release
s.release()

This results in:

ValueError: Semaphore released too many times

This can help detect programming mistakes involving unmatched release() operations.

Sometimes multiple Threads need to communicate with each other.

This concept is called Inter Thread Communication.

Python mechanisms covered in the tutorial are:

• Event
• Condition
• Queue

        Inter Thread Communication
                   │
         ┌─────────┼─────────┐
         │         │         │
         ▼         ▼         ▼
       Event   Condition    Queue

A common example of Inter Thread Communication is the Producer–Consumer model.

Producer Thread
      │
      ▼
Produce Item
      │
      ▼
Communicate
      │
      ▼
Consumer Thread
      │
      ▼
Consume Item

The Producer creates new items, while the Consumer waits for and consumes those items.

An Event provides a simple mechanism for communication between Threads.

Important methods covered in the tutorial:

• set()
• clear()
• is_set()
• wait()

Consumer
   │
   ▼
event.wait()
   │
   ▼
Waiting
   │
   │
   │ Producer
   │
   ▼
event.set()
   │
   ▼
Consumer Continues

Condition provides a more advanced communication mechanism.

Important methods:

• acquire()
• release()
• wait()
• notify()
• notify_all()

Consumer
   │
   ▼
acquire()
   │
   ▼
wait()
   │
   ▼
Waiting
   ▲
   │
   │ notify()
   │
Producer
   │
   ▼
acquire()
   │
   ▼
Produce Item
   │
   ▼
notify()
   │
   ▼
release()

The Consumer generally waits, while the Producer performs the update and sends the notification.

Queue provides an easy and powerful mechanism for sharing data between Threads.

The important methods are:

• put()
• get()

Producer
   │
   ▼
q.put(item)
   │
   ▼
 Queue
   │
   ▼
q.get()
   │
   ▼
Consumer

Queue automatically handles:

• Locking
• Waiting
• Notification

If a bounded Queue is full, a blocking Producer waits until space becomes available.

If the Queue is empty, a blocking Consumer waits until an item becomes available.

Queue Full
    │
    ▼
Producer Waits


Queue Empty
    │
    ▼
Consumer Waits

This synchronization is handled automatically by Queue.

Python Multi Threading
        │
        ├── Multi Tasking
        │      ├── Process Based
        │      └── Thread Based
        │
        ├── threading Module
        │
        ├── MainThread
        │
        ├── Thread Creation
        │      ├── Target Function
        │      ├── Extend Thread
        │      └── Normal Class Method
        │
        ├── Thread Operations
        │      ├── start()
        │      ├── run()
        │      └── join()
        │
        ├── Thread Information
        │      ├── name
        │      ├── ident
        │      ├── active_count()
        │      ├── enumerate()
        │      └── is_alive()
        │
        ├── Daemon Threads
        │
        ├── Synchronization
        │      ├── Lock
        │      ├── RLock
        │      ├── Semaphore
        │      └── BoundedSemaphore
        │
        └── Inter Thread Communication
               ├── Event
               ├── Condition
               └── Queue

• Multi Tasking means executing several tasks simultaneously.
• Multi Tasking can be Process Based or Thread Based.
• A Thread is an independent part of the same program.
• Python provides the threading module for Multi Threading.
• Every Python program starts with a default MainThread.
• Python supports three approaches to creating Threads covered in this tutorial.
• start() starts a Thread.
• run() contains the Thread's job when working with the Thread class.
• join() can make one Thread wait for another.
• Thread information can be obtained using names, ident, active_count(), enumerate(), and Thread-status methods.
• Daemon Threads provide background support to Non-Daemon Threads.
• Synchronization is used to protect shared resources from data inconsistency.
• Lock permits one Thread at a time.
• RLock supports repeated acquisition by the owning Thread.
• Semaphore permits a fixed number of Threads simultaneously.
• BoundedSemaphore can detect excessive releases.
• Event, Condition, and Queue are used for Inter Thread Communication.
• Event provides simple signaling.
• Condition provides controlled waiting and notification.
• Queue simplifies synchronized data sharing between Producer and Consumer Threads.

1. The threading module is used to develop multi-threaded Python applications.
2. Every Python program contains a Main Thread.
3. The execution order of multiple Threads is generally not predictable.
4. start() should be used to start a Thread.
5. join() is used when one Thread must wait for another Thread.
6. ident provides the Thread identification number.
7. active_count() returns the number of active Threads.
8. enumerate() returns active Thread objects.
9. Daemon Threads work in the background to support Non-Daemon Threads.
10. Synchronization is important when multiple Threads access shared resources.
11. Lock provides exclusive access to one Thread at a time.
12. RLock is useful when the owning Thread needs to acquire the same lock repeatedly.
13. Semaphore allows a fixed number of Threads to enter simultaneously.
14. BoundedSemaphore helps identify incorrect extra release() operations.
15. Event is the simplest Inter Thread Communication mechanism covered in this tutorial.
16. Condition provides more control over waiting and notification.
17. Queue provides automatic synchronization for Producer–Consumer data sharing.
18. The Producer generally uses put() with Queue.
19. The Consumer generally uses get() with Queue.
20. Queue automatically handles locking, waiting, and notification.