Python: Getting Current Thread

When you write programs with threads, multiple tasks can run at the same time. But inside each task, you might wonder: “Which thread is running this?” That’s where Python gives you a helpful tool.

The threading module includes a simple function: current_thread(). This lets you check the identity of the thread currently running your code. It’s especially useful when you’re working with multiple threads and want to log who’s doing what.

In this guide, we’ll explore how to use current_thread() through fun, hands-on examples. No theory—just how-tos, clear code, and easy explanations.

What is current_thread()?

In Python, every thread has a name and identity. The function threading.current_thread() gives you access to that. It returns a Thread object that represents the thread currently running the code.

This is helpful when you want to know which thread is doing what — especially when you’re logging messages or debugging a multithreaded app.

import threading

def show_current():
    # Get the current thread object
    t = threading.current_thread()
    print(f"Currently running: {t.name}")

show_current()

When you run this code, it prints the name of the main thread, because that’s where the function is called. Each thread has a name like 'MainThread', 'Thread-1', or any custom name you give it.

Basic Thread Example with current_thread()

Sometimes, it’s helpful to know which thread is running a piece of code—especially in multithreaded programs. By using threading.current_thread(), we can identify and label each thread as it runs.

In this example, we create a thread named "GreeterThread" and use current_thread() to print its name while it’s running.

import threading

def greet():
    # Get and print the current thread's name
    t = threading.current_thread()
    print(f"Hello from {t.name}!")

# Create and start a thread with a custom name
thread = threading.Thread(target=greet, name="GreeterThread")
thread.start()
thread.join()  # Wait for the thread to finish

When you run this, it prints “Hello from GreeterThread!”. This makes it clear which thread is saying hello — super handy when you have many threads working at once!

Naming Threads

Giving threads custom names makes your code easier to read and debug—especially when many threads are running at once. You can set a thread’s name when you create it, or assign it later before starting the thread.

import threading

def greet():
    t = threading.current_thread()
    print(f"Hello from {t.name}!")

# Create a thread and set its name after creation
t = threading.Thread(target=greet)
t.name = "CustomName"
t.start()
t.join()

This prints “Hello from CustomName!”. Thread names show up in logs, exceptions, and prints—so naming them helps track who’s doing what in a busy program.

Comparing Main Thread vs Custom Threads

Every Python program starts in the main thread, automatically named "MainThread". Any additional threads you create can have their own custom names. It’s often useful to check whether a piece of code is running in the main thread or in a worker thread.

import threading

def check_thread():

    t = threading.current_thread()

    if t.name == "MainThread":
        print("Running in the main thread")
    else:
        print(f"Running in a custom thread: {t.name}")


# Call from the main thread
check_thread()

# Call from a custom thread
worker = threading.Thread(target=check_thread, name="Worker")
worker.start()
worker.join()

The first call to check_thread() runs in the main thread and prints that it’s running in the main thread. The second call is executed inside a custom thread named "Worker" and prints that it’s running in a custom thread, showing the thread’s name.

This kind of check is handy when certain tasks should only run in the main thread (like updating a GUI or handling shutdowns), while others are better done in the background.

Using current_thread() for Debug Logs

When working with multiple threads, it can be helpful to include the thread’s name in your logs. This makes it easier to trace who is doing what, especially when things run at the same time. The current_thread() function lets you pull the name of the running thread and use it in messages or logs.

import threading

def debug_log(msg):
    # Get the name of the current thread and include it in the log
    name = threading.current_thread().name
    print(f"[{name}] {msg}")

def task():
    debug_log("Starting task...")

# Start a thread named 'TaskThread' that runs the task
thread = threading.Thread(target=task, name="TaskThread")
thread.start()
thread.join()

In this example, the message will show up as [TaskThread] Starting task..., clearly showing which thread the message came from. This is especially useful when you have lots of threads doing different things.

Loop Example: Multiple Threads Reporting Themselves

Sometimes you want many threads to do similar work but still know who they are. You can use a loop to create several threads, and each one can report its own name using current_thread().

import threading

def reporter():
    # Each thread prints its own name
    name = threading.current_thread().name
    print(f"Hello! I’m {name}")

# Start 3 threads with different names
for i in range(3):
    threading.Thread(target=reporter, name=f"Thread-{i}").start()

Each thread gets a unique name and introduces itself. This is a fun and clear way to watch multiple threads in action.

Using with Thread Subclasses

You can also use current_thread() inside a custom Thread class. This is helpful when you want to organize thread logic inside a class structure, especially for more complex programs.

import threading

# Define a custom thread class
class MyThread(threading.Thread):
    def run(self):
        # Print the current thread's name
        print(f"I’m running inside: {threading.current_thread().name}")

# Create an instance of the custom thread and start it
t = MyThread(name="SubClassedThread")
t.start()
t.join()

This creates a subclass of Thread, overrides the run() method, and uses current_thread() to display which thread is running. It’s a neat and clean way to manage thread behavior with object-oriented style.

Quick Reference Table

Conclusion

current_thread() lets you find out exactly which thread is running your code. It’s a simple but powerful tool to name, track, and debug threads in your Python programs. By customizing thread names and printing them, you make your code clearer and easier to follow — plus, it adds a bit of fun to working with threads! Give it a try in your next multithreading project.