Threads: A Party Story#

Imagine threads as individuals navigating their own lives, much like people managing their social interactions. To illustrate this concept, let’s delve into a story about two boys, Harold and Kumar, and their neighbor Maria, who are planning to attend a party.

In our Python model, we can represent each character as a thread, each with its own life and tasks to accomplish:

Lets define the Human behind the characters first#

class Human(threading.Thread):
    def i_am(self, msg):
        """I can speak ..."""
        print(f"{self.__class__.__name__}: I am {msg}")

Meet the Characters#

Harold: A go-getter, enthusiastic about life, and always ready to take on new challenges.

class Harold(Human):
    ...

I like how the ellipses object can be used as a placeholder for things that you are still thinking about…

Kumar: A laid-back guy who prefers to take it easy, often finding ways to avoid responsibility.

class Kumar(Human):
    ...

Maria: The girl next door, harboring a crush on Harold, and willing to do anything to spend time with him.

class Maria(Human):
    ...

The Party Invitation#

One day, the trio receives an invitation to a party. Maria is excited but has one condition: she will only attend if Harold goes. This sets the stage for a little drama, mirroring how threads interact in a program.

Setting the stage#

import threading
from threading import Event, Barrier
from time import sleep

Life of the characters#

As each thread runs, they each follow their own path:

Party, needs atleast 3 people to start else it wouldn’t be a party would it… We can use the Barrier object for this.

guests = 3
PARTY = Barrier(parties=guests)

Maria, caught in her feelings for Harold, anxiously waits for him to make a move. We need a way for the world to let Maria know if Harlod has attended the party. Let’s use the Event object for this.

HAROLD_HAS_ATTENDED = Event()

class Maria(Human):
    laziness = 1  
    def run(self):
        self.i_am("excited about the party")
        sleep(self.laziness)
        HAROLD_IS_ATTENDING.wait() # anxiously waiting and life feels stuck ...
        # At this point Harold has attended
        self.i_am("going too, Harold is joining the party!!! yay!")

        PARTY.wait()

        self.i_am("in now! I hope I see him today ...")

Harold is busy getting ready, excited about the party and the prospect of seeing Maria.

class Harold(Human):
    laziness = 1  
    def run(self):
        self.i_am("excited about the party")
        sleep(self.laziness)
        
        HAROLD_IS_ATTENDING.set()
        PARTY.wait()

        self.i_am("in now! Where the hell is Kumar ...")

Kumar, in his typical fashion, is weighing his options and considering not going.

class Kumar(Human):
    laziness = 5  
    def run(self):
        self.i_am("I am not very much excited about the party")
        sleep(self.laziness)

        PARTY.wait()

        self.i_am("in so much trouble Where is Harold?! he is not going to be happy that I am late...")

The God, ie main thread#

We have defined all characters but they don’t come to life until someone plays God, ie we need a thread whose main job is to give these characters a life. Guess who creates God?!

Luckily, when the program is started, the main thread comes to life, we don’t have to do anything special, all we have to do is define what needs to happen when the main thread is alive:

Lets define the actions for God#

Maria().start()
Harold().start()
Kumar().start()

The Outcome#

> python main.py 
Maria: I am excited about the party
Harold: I am excited about the party
Kumar: I am I am not very much excited about the party
Maria: I am going too, Harold is joining the party!!! yay!
Kumar: I am in so much trouble Where is Harold?! he is not going to be happy that I am late...
Harold: I am in now! Where the hell is Kumar ...
Maria: I am in now! I hope I see him today ...

After some time, once Harold is ready, he decides to go to the party, which influences Maria’s decision.

When Harold joins the party, Maria’s condition is satisfied, and she joins the party.

Since Kumar is lazy, he arrives late to the party.

The main thread’s job is done and the program completes successfuly, having done the God’s job for these characters.

This playful narrative not only captures the essence of how threads operate concurrently but also highlights how they can impact each other’s decisions, much like people do in real life.

Conclusion#

Threads are powerful tools that allow for parallel execution, much like how our characters navigate their lives and relationships. Each thread, with its own tasks and state, can affect the flow of the others, showcasing the complexity and interactivity that exists both in coding and in our daily interactions.

Just like Harold, Kumar, and Maria, threads can lead to unexpected yet entertaining outcomes!

Program#

import threading
from threading import Event, Barrier
from time import sleep

class Human(threading.Thread):
    def i_am(self, msg):
        print(f"{self.__class__.__name__}: I am {msg}")

guests = 3
PARTY = Barrier(parties=guests)
HAROLD_IS_ATTENDING = Event()

class Maria(Human):
    laziness = 1  
    def run(self):
        self.i_am("excited about the party")
        sleep(self.laziness)
        HAROLD_IS_ATTENDING.wait() # anxiously waiting and life feels stuck ...
        # At this point Harold has attended
        self.i_am("going too, Harold is joining the party!!! yay!")

        PARTY.wait()

        self.i_am("in now! I hope I see him today ...")


class Harold(Human):
    laziness = 1  
    def run(self):
        self.i_am("excited about the party")
        sleep(self.laziness)
        
        HAROLD_IS_ATTENDING.set()
        PARTY.wait()

        self.i_am("in now! Where the hell is Kumar ...")

class Kumar(Human):
    laziness = 5  
    def run(self):
        self.i_am("I am not very much excited about the party")
        sleep(self.laziness)

        PARTY.wait()

        self.i_am("in so much trouble Where is Harold?! he is not going to be happy that I am late...")


Maria().start()
Harold().start()
Kumar().start()