Python – Thread Life Cycle

Introduction

Understanding the life cycle of a thread is crucial for effective multithreading in Python. The life cycle of a thread in Python consists of several states, including creation, ready, running, waiting, and termination. Python’s threading module provides the necessary tools to manage these states.

Thread States

1. New: The thread is created but not yet started.
2. Runnable: The thread is ready to run and waiting for CPU time.
3. Running: The thread is currently being executed by the CPU.
4. Waiting/Blocked: The thread is waiting for a resource or for another thread to perform an action.
5. Terminated: The thread has finished its execution.

Thread Life Cycle Phases

1. New

When a thread object is created, it is in the New state.

Example

import threading

def thread_function():
    print("Thread is running")

# Creating a thread
thread = threading.Thread(target=thread_function)
print("Thread created, state: New")

2. Runnable

After calling the start() method, the thread moves to the Runnable state, where it waits for the CPU to schedule it.

Example

# Starting the thread
thread.start()
print("Thread state: Runnable")

3. Running

When the CPU starts executing the thread, it moves to the Running state.

Example

# The thread_function will print "Thread is running" when in the Running state

4. Waiting/Blocked

A thread can enter the Waiting or Blocked state for various reasons, such as waiting for I/O operations, acquiring a lock, or waiting for a condition.

Example: Waiting for I/O

import time

def thread_function():
    print("Thread is running")
    time.sleep(2)  # Simulating I/O wait
    print("Thread finished waiting")

thread = threading.Thread(target=thread_function)
thread.start()
print("Thread state: Waiting (I/O)")
thread.join()

Example: Waiting for a Lock

import threading

lock = threading.Lock()

def thread_function():
    with lock:
        print("Thread acquired the lock")
        time.sleep(2)
    print("Thread released the lock")

thread = threading.Thread(target=thread_function)
thread.start()
print("Thread state: Waiting (Lock)")
thread.join()

Example: Waiting for a Condition

condition = threading.Condition()

def consumer():
    with condition:
        condition.wait()  # Waiting for the condition to be notified
        print("Consumer thread notified")

def producer():
    with condition:
        print("Producer thread notifying")
        condition.notify()

consumer_thread = threading.Thread(target=consumer)
producer_thread = threading.Thread(target=producer)

consumer_thread.start()
time.sleep(1)
producer_thread.start()

consumer_thread.join()
producer_thread.join()

5. Terminated

When the thread has finished executing its target function, it moves to the Terminated state.

Example

def thread_function():
    print("Thread is running")
    time.sleep(2)
    print("Thread is terminating")

thread = threading.Thread(target=thread_function)
thread.start()
thread.join()  # Wait for the thread to complete
print("Thread state: Terminated")

Thread State Transitions

• New to Runnable: When start() is called.
• Runnable to Running: When the thread gets CPU time.
• Running to Waiting/Blocked: When the thread waits for I/O, acquires a lock, or waits for a condition.
• Waiting/Blocked to Runnable: When the waiting condition is met (e.g., I/O completes, lock is acquired, condition is notified).
• Running to Terminated: When the thread completes execution.

Thread Life Cycle Diagram

New ----> Runnable ----> Running ----> Terminated
          ^    |             |
          |    |             |
          |    v             v
          |  Waiting <--- Blocked
          |       |
          +-------+

Conclusion

Understanding the life cycle of a thread helps in managing and synchronizing threads effectively. Python’s threading module provides the necessary tools to handle threads in various states, allowing you to build efficient multithreaded applications. By understanding the states and transitions, you can better design and debug your multithreaded programs.