Of course! In Python, making one thread wait for another is a fundamental concept in multithreading. The primary and most common way to achieve this is by using the threading.Thread.join() method.

Let's break it down.

The Core Concept: threading.Thread.join()

The join() method is called on a Thread object and it does one simple thing: it blocks the calling thread until the thread on which join() is called has completed its execution.

Think of it like a real-life "join" in a line. The main program (the main thread) has to "wait in line" (join()) for the worker thread to finish its task before it can proceed.

The Basic join() Method

This is the simplest form. The main thread will pause indefinitely until the target thread is finished.

Example: Without join() (Incorrect Behavior)

First, let's see what happens when you don't use join(). The main thread might finish before the worker thread, leading to unexpected results.

import threading
import time
def long_running_task():
    """A function that simulates a task taking 3 seconds."""
    print(f"Worker thread ({threading.current_thread().name}) has started.")
    time.sleep(3)  # Simulate work
    print(f"Worker thread ({threading.current_thread().name}) has finished.")
# Create a thread
worker_thread = threading.Thread(target=long_running_task, name="Worker-1")
# Start the thread
worker_thread.start()
# The main thread continues immediately without waiting
print("Main thread is continuing its work...") # This might print before the worker is done
print("Main thread is about to exit.")
# The program might exit here before worker_thread finishes,
# especially in a script, because the main thread has ended.

Output (Possible):

Worker thread (Worker-1) has started.
Main thread is continuing its work...
Main thread is about to exit.
# (Program might exit here, and you might not see the next line)
Worker thread (Worker-1) has finished.

Example: With join() (Correct Behavior)

Now, let's fix this by adding worker_thread.join().

import threading
import time
def long_running_task():
    """A function that simulates a task taking 3 seconds."""
    print(f"Worker thread ({threading.current_thread().name}) has started.")
    time.sleep(3)  # Simulate work
    print(f"Worker thread ({threading.current_thread().name}) has finished.")
# Create a thread
worker_thread = threading.Thread(target=long_running_task, name="Worker-1")
# Start the thread
worker_thread.start()
# The main thread will now WAIT here until worker_thread is complete.
print("Main thread is waiting for the worker thread to finish...")
worker_thread.join() # <--- The key line
# This line will only be executed AFTER the worker thread has finished.
print("Main thread has resumed and is about to exit.")

Output (Guaranteed):

Worker thread (Worker-1) has started.
Main thread is waiting for the worker thread to finish...
# (3-second pause here)
Worker thread (Worker-1) has finished.
Main thread has resumed and is about to exit.

Advanced join() Usage: Timeout

Sometimes, you don't want to wait forever. You might want to wait for a certain amount of time and then proceed regardless of whether the other thread has finished. For this, join() accepts an optional timeout argument (in seconds).

• If the thread finishes within the timeout, join() returns None.
• If the timeout expires and the thread is still running, join() also returns None, but the main thread is no longer blocked.

Example: Using join(timeout=...)

import threading
import time
def long_running_task():
    """A function that simulates a task taking 5 seconds."""
    print(f"Worker thread ({threading.current_thread().name}) has started.")
    time.sleep(5)  # Simulate work
    print(f"Worker thread ({threading.current_thread().name}) has finished.")
# Create a thread
worker_thread = threading.Thread(target=long_running_task, name="Worker-1")
worker_thread.start()
# Wait for a maximum of 2 seconds
print("Main thread is waiting for the worker thread for 2 seconds...")
worker_thread.join(timeout=2) # <--- Wait for 2 seconds max
# Check if the thread is still alive after the timeout
if worker_thread.is_alive():
    print("Timeout! The worker thread is still running. Main thread is continuing.")
else:
    print("The worker thread finished within the 2-second timeout.")
print("Main thread is now exiting.")

Output:

Worker thread (Worker-1) has started.
Main thread is waiting for the worker thread for 2 seconds...
# (2-second pause here)
Timeout! The worker thread is still running. Main thread is continuing.
Main thread is now exiting.
# (3 more seconds pass)
Worker thread (Worker-1) has finished.

Waiting for Multiple Threads

If you have a list of threads and want to wait for all of them to complete, you can simply loop through them and call join() on each one.

import threading
import time
def task(name, duration):
    print(f"Task {name} has started.")
    time.sleep(duration)
    print(f"Task {name} has finished.")
# Create a list of threads
threads = []
threads.append(threading.Thread(target=task, args=("A", 2)))
threads.append(threading.Thread(target=task, args=("B", 3)))
threads.append(threading.Thread(target=task, args=("C", 1)))
# Start all threads
for t in threads:
    t.start()
print("\nMain thread is waiting for all tasks to complete...")
# Join all threads
for t in threads:
    t.join()
print("\nAll tasks have finished. Main thread is exiting.")

Output:

Task A has started.
Task B has started.
Task C has started.
Main thread is waiting for all tasks to complete...
# (3-second pause, as the longest task takes 3 seconds)
Task C has finished.
Task A has finished.
Task B has finished.
All tasks have finished. Main thread is exiting.

Alternatives to join()

While join() is the most straightforward method, other concurrency primitives can be used for more complex synchronization scenarios.

threading.Event

An Event is a simple flag that threads can set and wait for. It's useful when you don't need to wait for the thread's entire lifecycle, just for a specific signal.

import threading
import time
def waiter(event):
    print("Waiter thread is waiting for the event to be set...")
    event.wait() # Blocks until event.set() is called
    print("Event has been set! Waiter thread is now running.")
event = threading.Event()
worker = threading.Thread(target=waiter, args=(event,))
worker.start()
# The main thread does some other work
time.sleep(2)
print("Main thread is setting the event now.")
event.set() # Signal the waiter thread
worker.join() # Still good practice to ensure clean exit

threading.Condition

A Condition is more powerful. It allows one or more threads to wait until they are notified by another thread. It's like a more advanced Event.

queue.Queue

If you are using a Queue for thread-safe communication, the queue.get() method will also block a thread until an item is available in the queue. This is a common pattern for the Producer-Consumer problem.

import threading
import queue
import time
def consumer(q):
    print("Consumer is waiting for an item...")
    item = q.get() # This will BLOCK until an item is put in the queue
    print(f"Consumer got item: {item}")
q = queue.Queue()
worker = threading.Thread(target=consumer, args=(q,))
worker.start()
# The main thread (producer) does some work
time.sleep(3)
print("Producer is putting an item in the queue.")
q.put("Hello from Producer!")
worker.join()

Summary: When to Use What

For most general-purpose "wait for thread to finish" scenarios, threading.Thread.join() is the tool you should use.