Python - Thread Pools

A thread pool is a mechanism that automatically manages multiple threads efficiently, allowing tasks to be executed concurrently. Python does not provide thread pooling directly through thethreading module.

Instead, it offers thread-based pooling through themultiprocessing.dummy module and theconcurrent.futures module. These modules provide convenient interfaces for creating and managing thread pools, making it easier to perform concurrent task execution.

What is a Thread Pool?

A thread pool is a collection of threads that are managed by a pool. Each thread in the pool is called a worker or a worker thread. These threads can be reused to perform multiple tasks, which reduces the burden of creating and destroying threads repeatedly.

Thread pools control the creation of threads and their life cycle, making them more efficient for handling large numbers of tasks.

We can implement thread-pools in Python using the following classes −

• Python ThreadPool Class
• Python ThreadPoolExecutor Class

Using Python ThreadPool Class

Themultiprocessing.pool.ThreadPool class provides a thread pool interface within themultiprocessing module. It manages a pool of worker threads to which jobs can be submitted for concurrent execution.

A ThreadPool object simplifies the management of multiple threads by handling the creation and distribution of tasks among the worker threads. It shares an interface with thePool class, originally designed for processes, but has been adjusted to work with threads too.

ThreadPool instances are fully interface-compatible withPool instances and should be managed either as a context manager or by calling close() and terminate() manually.

Example

This example demonstrates the parallel execution of the square and cube functions on the list of numbers using the Pythonthread pool, where each function is applied to the numbers concurrently with up to 3 threads, each with a delay of 1 second between executions.

from multiprocessing.dummy import Pool as ThreadPoolimport timedef square(number):   sqr = number * number   time.sleep(1)   print("Number:{} Square:{}".format(number, sqr))def cube(number):   cub = number*number*number   time.sleep(1)   print("Number:{} Cube:{}".format(number, cub))numbers = [1, 2, 3, 4, 5]pool = ThreadPool(3)pool.map(square, numbers)pool.map(cube, numbers)pool.close()

Output

On executing the above code you will get the following output −

Number:2 Square:4Number:1 Square:1Number:3 Square:9Number:4 Square:16Number:5 Square:25Number:1 Cube:1Number:2 Cube:8Number:3 Cube:27Number:4 Cube:64Number:5 Cube:125

Using Python ThreadPoolExecutor Class

TheThreadPoolExecutor class of the Python theconcurrent.futures module provides a high-level interface for asynchronously executing functions using threads. The concurrent.futures module includesFuture class and two Executor classes −ThreadPoolExecutor andProcessPoolExecutor.

The Future Class

Theconcurrent.futures.Future class is responsible for handling asynchronous execution of any callable such as a function. To obtain aFuture object, you should call thesubmit() method on anyExecutor object. It should not be created directly by its constructor.

Important methods in the Future class are −

• result(timeout=None): This method returns the value returned by the call. If the call hasn't yet completed, then this method will wait up to timeout seconds. If the call hasn't completed in timeout seconds, then a TimeoutError will be raised. If timeout is not specified, there is no limit to the wait time.
• cancel(): This method, attempt to cancel the call. If the call is currently being executed or finished running and cannot be cancelled then the method will return a boolean valueFalse. Otherwise the call will be cancelled and the method returns True.
• cancelled(): Returns True if the call was successfully cancelled.
• running(): Returns True if the call is currently being executed and cannot be cancelled.
• done(): Returns True if the call was successfully cancelled or finished running.

The ThreadPoolExecutor Class

This class represents a pool of specified number maximum worker threads to execute calls asynchronously.

concurrent.futures.ThreadPoolExecutor(max_threads)

Example

Here is an example that uses theconcurrent.futures.ThreadPoolExecutor class to manage and execute tasks asynchronously in Python. Specifically, it shows how to submit multiple tasks to a thread pool and how to check their execution status.

from concurrent.futures import ThreadPoolExecutorfrom time import sleepdef square(numbers):   for val in numbers:      ret = val*val      sleep(1)      print("Number:{} Square:{}".format(val, ret))def cube(numbers):   for val in numbers:      ret = val*val*val      sleep(1)      print("Number:{} Cube:{}".format(val, ret))if __name__ == '__main__':   numbers = [1,2,3,4,5]   executor = ThreadPoolExecutor(4)   thread1 = executor.submit(square, (numbers))   thread2 = executor.submit(cube, (numbers))   print("Thread 1 executed ? :",thread1.done())   print("Thread 2 executed ? :",thread2.done())   sleep(2)   print("Thread 1 executed ? :",thread1.done())   print("Thread 2 executed ? :",thread2.done())

It will produce the followingoutput −

Thread 1 executed ? : FalseThread 2 executed ? : FalseNumber:1 Square:1Number:1 Cube:1Thread 1 executed ? : FalseThread 2 executed ? : FalseNumber:2 Square:4Number:2 Cube:8Number:3 Square:9Number:3 Cube:27Number:4 Square:16Number:4 Cube:64Number:5 Square:25Number:5 Cube:125