2.1. Basic Thread Example

import threading
import time

In this chunk, we start by importing the necessary modules: threading and time. The threading module allows us to work with threads, while the time module provides us with time-related functions. This setup prepares our program to create and manage threads effectively.

Think of import threading as gathering your tools before building a piece of furniture. Just like you wouldn't start building without a hammer or screwdriver, you need to import the right modules before writing your threading program.

def task(name):
    print(f"Starting {name}")
    time.sleep(2)
    print(f"Finished {name}")

Here, we define a function named task, which takes one parameter called name. Inside this function, we print a message indicating that the task is starting. The time.sleep(2) function simulates a delay of 2 seconds, which represents a time-consuming operation. After the delay, we print another message indicating that the task is finished.

Imagine you're calling a friend to help with a task. You tell them to start, and then you both take a break for two minutes while waiting for something to brew, like coffee. After the wait, you check in to see that the task is done. This is similar to how our function runs.

thread1 = threading.Thread(target=task, args=("Thread 1",))
thread2 = threading.Thread(target=task, args=("Thread 2",))

In this part, we create two threads: thread1 and thread2. Each thread is an instance of the Thread class, and we specify that they should run the previously defined task function. We pass different names for each thread as arguments. The use of args allows us to provide the necessary parameters to the function when the thread starts executing.

Think of these threads as two workers assigned to different tasks in a bakery. Worker 1 is baking bread, while Worker 2 is preparing pastries. Each worker follows the same process (the task function), but with different items (the arguments).

thread1.start()
thread2.start()

Here, we call the start() method on both threads. This method begins the execution of the task function in separate threads, allowing both tasks to run concurrently. Importantly, start() does not block the main program; both threads will run simultaneously, each printing its start and finish messages after their respective delays.

Imagine you’ve instructed both workers (threads) to start their tasks at the same time. While one worker is baking, the other is preparing pastries. This way, both jobs progress concurrently instead of waiting for one to finish before starting the next.

thread1.join()
thread2.join()

In this chunk, we call the join() method on both threads. join() is crucial because it allows the main program to wait for both threads to complete their execution before proceeding. This ensures that any code following these calls will only run after both threads have finished their tasks.

Think of this step as waiting for both workers in our bakery to finish their tasks before opening the shop. You wouldn’t want customers to enter while the workers are still busy baking and preparing, so you let them finish before moving on to serve customers.

--