Article complete

How To Run Python Code Concurrently Using Multithreading

Multithreading in Python enables CPUs to run different parts(threads) of a process concurrently to maximize CPU utilization.

How To Run Python Code Concurrently Using Multithreading

Key takeaways

  • Multithreading in Python allows concurrent execution of different parts of a process, maximising CPU utilisation.
  • It is particularly beneficial for tasks with IO or network operations that involve waiting.
  • The Python 'threading' module is included in the standard library, enabling easy thread creation.
  • Multithreading differs from multi-processing, which runs processes in parallel across multiple CPU cores.

Takeaways drafted with AI from the article text.

Note that multithreading is not to be confused with multi-processing. Modern CPUs have multiple cores; multi-processing utilizes these cores to run processes in parallel. Multithreading, however, aims to maximize the utilization of each of these cores by running multiple threads concurrently. Multithreading is useful when the task has IO or network operations that involve waiting; multiprocessing makes computation-intensive tasks of a process faster. Continuing the online game example, the render thread of most games are run in parallel on a GPU with thousands of cores, each thread rendering different aspects of the game. While the communication and IO threads are run concurrently on the CPU. 

Multithreading in Python

The threading module comes with the standard Python library, so there’s no need for installing anything. By default, your Python programs have a single thread, called the main thread. You can create threads by passing a function to the Thread() constructor or by inheriting the Thread class and overriding the run() method.

Using the Thread() Constructor

 import threading
 import time

 def useless_function(seconds):
     print(f'Waiting for {seconds} second(s)', end = "\n")
     time.sleep(seconds)
     print(f'Done Waiting {seconds}  second(s)')

 start = time.perf_counter()
 t = threading.Thread(target=useless_function, args=[1])
 t.start()
 print(f'Active Threads: {threading.active_count()}')
 t.join()
 end = time.perf_counter()
 print(f'Finished in {round(end-start, 2)} second(s)') 
-----------------------------Output-----------------------------
 Waiting for 1 second(s)
 Active Threads: 2
 Done Waiting 1  second(s)
 Finished in 1.0 second(s) 

The two active threads are the main thread and the useless_function thread that you just created. The join() method blocks the execution flow until the thread t terminates. If you were to remove the join() call, the main thread would finish before t, and the output would be something like.

-----------------------------Output-----------------------------
 Waiting for 1 second(s)
 Active Threads: 2
 Finished in 0.0 second(s) 

Although the active_count() method is called after starting the thread t, it finishes execution before it. This happens because the processor runs the main thread while the thread t is sleeping. If you were to add a delay of 1 second before it, it would be executed after the thread t terminates. 

 t = threading.Thread(target=useless_function, args=[1])
 start = time.perf_counter()
 t.start()
 time.sleep(1)
 print(f'Active Threads: {threading.active_count()}')
 end = time.perf_counter()
 print(f'Finished in {round(end-start, 2)} second(s)') 
-----------------------------Output-----------------------------
 Waiting for 1 second(s)
 Done Waiting 1  second(s)
 Active Threads: 2
 Finished in 1.0 second(s) 

Creating Your Thread Class

The Thread subclass should only override the run() method and the __init__() constructor. And if the constructor is overridden the base class constructor, Thread.__init__(self), should be invoked before doing anything else.

 from thread import Thread

 def countdown(name, delay, count):
     while count:
         time.sleep(delay)
         print (f'{name, time.ctime(time.time()), count}')
         count -= 1

 class newThread(Thread):
     def __init__(self, name, count):
         threading.Thread.__init__(self)
         self.name = name
         self.count = count
     def run(self):
         print("Starting: " + self.name + "\n")
         countdown(self.name, 1,self.count)
         print("Exiting: " + self.name + "\n")

 t = newThread("Thread 1", 5)
 t.start()
 t.join()
 print("Exiting Main Thread") 
-----------------------------Output-----------------------------
 Starting: Thread 1
 ('Thread 1', 'Thu Apr 22 06:29:57 2021', 5) 
 ('Thread 1', 'Thu Apr 22 06:29:58 2021', 4) 
 ('Thread 1', 'Thu Apr 22 06:29:59 2021', 3) 
 ('Thread 1', 'Thu Apr 22 06:30:00 2021', 2) 
 ('Thread 1', 'Thu Apr 22 06:30:01 2021', 1) 
 Exiting: Thread 1
 Exiting Main Thread 

Now you know how to run code concurrently using multithreading in Python, but why would you want to do so? Let’s illustrate the concurrency aspect of multithreading and the increased CPU utilization with the help of an example. 

Unoptimized Code
 import requests
 import time

 urls = [
     'https://images.pexels.com/photos/305821/pexels-photo-305821.jpeg',
     'https://images.pexels.com/photos/509922/pexels-photo-509922.jpeg',
     'https://images.pexels.com/photos/325812/pexels-photo-325812.jpeg',
     'https://images.pexels.com/photos/1252814/pexels-photo-1252814.jpeg',
     'https://images.pexels.com/photos/1420709/pexels-photo-1420709.jpeg',
     'https://images.pexels.com/photos/963486/pexels-photo-963486.jpeg',
     'https://images.pexels.com/photos/1557183/pexels-photo-1557183.jpeg',
     'https://images.pexels.com/photos/3023211/pexels-photo-3023211.jpeg',
     'https://images.pexels.com/photos/1031641/pexels-photo-1031641.jpeg',
     'https://images.pexels.com/photos/439227/pexels-photo-439227.jpeg',
     'https://images.pexels.com/photos/696644/pexels-photo-696644.jpeg',
     'https://images.pexels.com/photos/911254/pexels-photo-911254.jpeg',
     'https://images.pexels.com/photos/1001990/pexels-photo-1001990.jpeg',
     'https://images.pexels.com/photos/3518623/pexels-photo-3518623.jpeg',
     'https://images.pexels.com/photos/916044/pexels-photo-916044.jpeg'
 ]

 def download(url):
     img_data = requests.get(url).content
     img_name = url.split('/')[4]
     img_name = f'{img_name}.jpg'
     with open(img_name, 'wb') as img_file:
         img_file.write(img_data)
         print(f'downloading {img_name}')

 t1 = time.perf_counter()
 for i in urls:
     download(i)
 t2 = time.perf_counter()
 print(f'Finished in {t2-t1} seconds') 
-----------------------------Output-----------------------------
 downloading 305821.jpg
 downloading 509922.jpg
 downloading 325812.jpg
 downloading 1252814.jpg
 downloading 1420709.jpg
 downloading 963486.jpg
 downloading 1557183.jpg
 downloading 3023211.jpg
 downloading 1031641.jpg
 downloading 439227.jpg
 downloading 696644.jpg
 downloading 911254.jpg
 downloading 1001990.jpg
 downloading 3518623.jpg
 downloading 916044.jpg
 Finished in 5.95 seconds 
Multithreaded Code
 start = time.perf_counter()
 threads = []
 for i in urls:
     t = threading.Thread(target=download, args=[i])
     t.start()
     threads.append(t)
 for thread in threads:
     thread.join()
 finish = time.perf_counter()
 print(f'Finished in {round(finish-start, 2)} seconds') 
-----------------------------Output-----------------------------
 downloading 509922.jpg
 downloading 963486.jpg
 downloading 305821.jpg
 downloading 3023211.jpg
 downloading 325812.jpg
 downloading 696644.jpg
 downloading 1557183.jpg
 downloading 1420709.jpg
 downloading 1252814.jpg
 downloading 1001990.jpg
 downloading 911254.jpg
 downloading 1031641.jpg
 downloading 916044.jpg
 downloading 3518623.jpg
 downloading 439227.jpg
 Finished in 1.41 seconds 

The two loops can be replaced with Executor() object from concurrent.futures:

 import concurrent.futures
 start = time.perf_counter()
 with concurrent.futures.ThreadPoolExecutor() as executor:
     executor.map(download, urls)
 finish = time.perf_counter()
 print(f'Finished in {round(finish-start, 2)} seconds') 

The Executor object creates a thread for each function call and blocks the main thread’s execution until each of these threads is terminated. 

In the unoptimized code, the GET requests happen sequentially, and the CPU is ideal between the requests. When each GET request happens in its separate thread, all of them are executed concurrently, and the CPU alternates between them instead of being ideal. 

References:

To learn more about the Python threading module, refer to the following resources:

Published

Corrections: AIM corrects errors of fact and notes the change on the story. Spotted one? Tell the editors. Read our editorial standards.

More in this story

5 stories
  1. You are here: How To Run Python Code Concurrently Using Multithreading
  2. OpenAI is Two Stages Shy of Hitting AGI 
  3. ​​Anthropic, DeepMind, Node.js Leaders Believe Era of Humans Writing Code is Over
  4. ‘The World Needs 1000x More Software,’ Says Fractal CEO
  5. Anthropic Stands Alone Against Open Models
About the author

Contributor

A machine learning enthusiast with a knack for finding patterns. In my free time, I like to delve into the world of non-fiction books and video essays.

All stories
Belamy · Daily

The day’s AI news, before your first meeting.