What is Multithreading in Python: Simple Explanation and Example

In Python, multithreading means running multiple threads (small tasks) at the same time within a single program to make it faster or more responsive. Threads share the same memory space but run independently, allowing tasks like waiting for input or downloading files to happen together.

How It Works

Imagine you are cooking a meal and doing several things at once: chopping vegetables, boiling water, and stirring a pot. Each of these tasks is like a thread in a program. Multithreading lets your program do many small jobs at the same time, so it doesn't have to wait for one task to finish before starting another.

In Python, threads share the same memory, so they can easily share information. However, because of the Global Interpreter Lock (GIL), only one thread runs Python bytecode at a time, but threads can still be useful for tasks that wait for things like file reading or network responses.

Example

This example shows two threads printing messages with pauses. They run together, so the messages mix instead of waiting for one thread to finish.

python

import threading
import time

def print_numbers():
    for i in range(1, 6):
        print(f"Number: {i}")
        time.sleep(1)

def print_letters():
    for letter in ['A', 'B', 'C', 'D', 'E']:
        print(f"Letter: {letter}")
        time.sleep(1)

thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

Output

Number: 1
Letter: A
Number: 2
Letter: B
Number: 3
Letter: C
Number: 4
Letter: D
Number: 5
Letter: E

When to Use

Use multithreading in Python when your program needs to do many tasks that wait for things, like reading files, downloading data, or handling user input. It helps keep your program responsive and faster by not making it wait for one task to finish before starting another.

However, for heavy calculations, multithreading may not speed up your program because of Python's GIL. In those cases, multiprocessing or other methods are better.

Key Points

• Multithreading runs multiple threads in one program to do tasks at the same time.
• Threads share memory but only one runs Python bytecode at a time due to the GIL.
• Best for tasks that wait on input/output, like file or network operations.
• Not ideal for CPU-heavy tasks; use multiprocessing instead.

Key Takeaways

Multithreading lets Python run multiple small tasks together to improve responsiveness.

Threads share memory but Python runs only one thread at a time for code execution.

Use multithreading mainly for I/O-bound tasks like file reading or network calls.

For CPU-heavy work, prefer multiprocessing to bypass Python's GIL limitations.