python threading

In Python, threads can be effortlessly created using the thread module in Python 2.x and the _thread module in Python 3.x. For a more convenient interaction, the threading module is preferred.
Threads differ from conventional processes in various ways. For instance:

• Threads exist within a process, acting as a subset.
• All threads within a process share the same memory and resources.
• In contrast, different processes have separate memory address spaces.

You might wonder, when is threading useful? Well, consider scenarios where you need simultaneous executions. For instance, if you’re developing server software, it should ideally handle multiple connections simultaneously rather than just one. Essentially, threading enables concurrency, letting programs manage multiple tasks at once.

Related Course:

• Python Programming Bootcamp: Go from zero to hero

Python Threading in Practice

Let’s delve into a practical example. We’ll create a program that initiates 10 threads, with each one displaying its unique ID.

import threading

# Defining our thread class
class MyThread(threading.Thread):
    def __init__(self, x):
        self.__x = x
        threading.Thread.__init__(self)

    def run(self):
          print(str(self.__x))

# Initiating 10 threads
for x in range(10):
    MyThread(x).start()

Output:

0
1
...
9

A point to note is that threads aren’t restricted to a single execution. You can configure threads to operate on a timer, enabling them to execute their functionality after set intervals.

Delving into Timed Threads

Python offers the Timer class, which is essentially a subclass of the Thread class. This means its functionality is quite similar. With the timer class, we can craft threads that start after a specified duration. For instance, the subsequent program initializes a thread that kicks off after a delay of 5 seconds.

#!/usr/bin/env python
from threading import Timer

def hello():
    print("hello, world")

# Defining the thread
t = Timer(10.0, hello)

# Launching the thread after a 10-second delay
t.start()

Continuous Execution with Threads

If you need threads to execute repeatedly, here’s how you can accomplish that:

#!/usr/bin/env python
from threading import Timer
import time

def handleClient1():
    while True:
        print("Waiting for client 1...")
        time.sleep(5)  # Pausing for 5 seconds      

def handleClient2():
    while True:
        print("Waiting for client 2...")
        time.sleep(5)  # Pausing for 5 seconds

# Thread definitions
t = Timer(5.0, handleClient1)
t2 = Timer(3.0, handleClient2)

# Starting the threads
t.start()
t2.start()

Threading, when applied correctly, can significantly boost the efficiency and responsiveness of your Python programs.