Problem Statement:
Demonstrate the usage of threading in python.

Scripts:
Let’s consider an example where we have two scripts, one of them is the “main.py” script that can be considered as parent and the other that would run in threads “log.py”.

Let’s first take a look at
“log.py”
———
import time

class log:
def __init__(self, times):
self.times = times
self._bOn = True

def start(self):
while (self._bOn):
print “in start”
time.sleep(self.times)

def stop(self):
self._bOn = False
print “in stop”

log.py contains a class log with constructor that takes argument for time and sets the bOn variable to True.
start() – starts printing “in start” till the time bOn is True.
stop() – prints “in stop” when it is called. It would also stop the start() function as bOn is set to False now.

Now on to the parent script that would call log.py to run in thread.
“Main.py”
———-
import os
import log
import time
import thread

obj = log.log(5)

def startlog():
print “in thread”
obj.start()

thread.start_new_thread(startlog,())
time.sleep(11)
obj.stop()

Main.py, imports log.py with constructor argument as “5”.
startlog() – prints “in thread” and then would call start() of log.py
startlog() is now run as a thread
Main script sleeps for 11 seconds and then
calls the stop() of log.py

Explanation:
In this example, when Main.py starts running, it imports log.py and sets the argument(time) of the constructor to 5. It then starts a thread for the function startlog() and goes to sleep for 11 seconds.
Now that a thread has started with startlog() function, it prints “in thread”, then calls start() of log.py. Now that bOn is True, it prints “in start” and sleeps for 5 seconds as set by Main.py. After 5 seonds again it prints “in start”.
During this time the Main.py is still sleeping. When 11 seconds pass by, Main.py comes out of sleep (log.py is still running though) and calls the stop() of log.py. Because of which, start() gets stopped as bOn is now set to False and it prints “in stop”.
Thus we have seen, Main.py and log.py both ran in parallel and Main.py could control the execution of log.py as it was run in thread.