You can kill running tasks in the ThreadPoolExecutor by running the ThreadPoolExecutor in a new child process and calling the terminate() or kill() method on the child process.

This will abruptly and immediately terminate the child process and terminate all worker threads running in the ThreadPoolExecutor.

In this tutorial, you will discover how to kill running tasks in the ThreadPoolExecutor.

Let’s get started.

shutdown() Won’t Stop Running Tasks in the ThreadPoolExecutor

The ThreadPoolExecutor provides a pool of reusable worker threads using the executor design pattern.

Tasks executed in new threads are executed concurrently in Python, making the ThreadPoolExecutor appropriate for I/O-bound tasks.

A ThreadPoolExecutor can be created directly or via the context manager interface and tasks can be issued one-by-one via the submit() method or in batch via the map() method.

For example:

You can learn more about the ThreadPoolExecutor in the tutorial:

• ThreadPoolExecutor in Python: The Complete Guide

The ThreadPoolExecutor can be shut down by calling the shutdown() method.

For example:

This call can be configured to block until all tasks are done or return immediately and cancel all pending tasks or not.

You can learn more about how to shut down the ThreadPoolExecutor in the tutorial:

• How to Shutdown the ThreadPoolExecutor in Python

Shutting down the ThreadPoolExecutor will not terminate running tasks.

It is possible to update tasks to check a shared variable and terminate of their own accord. You can see an example of this in the tutorial:

• How To Stop Running Tasks in the ThreadPoolExecutor in Python

Nevertheless, we cannot immediately terminate tasks running in the ThreadPoolExecutor.

Even if the program exists, the Python interpreter will wait for all threads in the ThreadPoolExecutor to complete and be released before the program terminates.

How can we forcefully terminate all running tasks in the ThreadPoolExecutor?

How to Kill All Running Tasks in the ThreadPoolExecutor

There are a few ways that we may implement the forceful termination of worker threads in the ThreadPoolExecutor.

An approach I prefer is to host the ThreadPoolExecutor in a separate child process, then terminate the entire process in order to forcefully stop all running tasks.

For example, we can define a new function that creates and manages the ThreadPoolExecutor.

We can then create a new multiprocessing.Process instance to run the function in a child process.

For example:

You can learn more about running functions in a child process in the tutorial:

• Run a Function in a Child Process

Finally, when we want to stop all tasks immediately, we can call the terminate() method on the process.

For example:

You can learn more about terminating and killing child processes in the tutorial:

• Kill a Process in Python

This is a clean solution in that it does not require that the ThreadPoolExecutor class or the Future class be customized with workers or tasks that can be killed.

Instead, it provides a single point at which all workers and all helper threads in the ThreadPoolExecutor can be killed immediately.

The downside is that the ThreadPoolExecutor is not recoverable. It is terminated along with the workers. It also has the downside that any data needed by workers or any results produced by workers must be transferred from to or from the new child process, which can be costly if there is a lot of data involved.

Another downside is that tasks may be terminated mid-operation. This means that data or program state may be left inconsistent.

Now that we know how to forcefully terminate all workers in the ThreadPoolExecutor, let’s look at a worked example.

Example of Killing All Running Tasks in the ThreadPoolExecutor

We can develop an example that explores how to forcefully stop all worker threads in the ThreadPoolExecutor.

In this example, we will define a simple task to execute many times in our thread pool. We will then define a function that will be used to manage the thread pool in a new process. Finally, the main process will create a new child process to manage the thread pool, wait a while, then terminate the child process along with all running worker threads.

Firstly, we can define a task to execute in the thread pool.

The task tasks a unique integer argument sleeps for a moment to simulate doing work, then reports a message with its unique identifier.

These print messages will give us some idea that tasks are running and being completed in the thread pool.

The task() function below implements this.

Next, we can define a function to manage the ThreadPoolExecutor and issue all tasks, which will be executed in a child process.

The function will report a message at the beginning and end so we have some idea if the function is running and finished normally.

A ThreadPoolExecutor is created normally using the context manager interface with two worker threads. Then 10 task() calls are issued to the pool with unique arguments from 0 to 9.

The context manager interface ensures that the pool is closed automatically if the block is exited, blocking until all tasks are completed.

The tpe_runner() function below implements this.

Finally, we can develop the code in the main process.

First, we will create a new process to run our tpe_runner() function, then start this process.

Next, the main process will block moments to allow some tasks to run and complete.

Finally, the main process terminates the child process running the ThreadPoolExecutor.

Tying this together, the complete example is listed below.

Running the example first creates a new child process to run our tpe_runner() function. Then the new child process is started.

Next, the main process reports a message and blocks with a sleep.

The child process runs, reports a message then creates the ThreadPoolExecutor. All 10 task() calls are issued to the ThreadPoolExecutor and the child process until all tasks are complete.

The two worker threads in the ThreadPoolExecutor run and execute task() functions with unique arguments.

Two tasks are completed, then two more.

The main thread resumes and terminates the child process.

This immediately stops the child process and in turn, it terminates the ThreadPoolExecutor. This includes the termination of the two running worker threads and any helper threads internal to the ThreadPoolExecutor.

A final message is reported and the program terminates, again, not waiting for the workers in the child process to terminate.

This highlights how we can immediately terminate running tasks in the ThreadPoolExecutor.

Further Reading

This section provides additional resources that you may find helpful.

Books

• ThreadPoolExecutor Jump-Start, Jason Brownlee, (my book!)
• Concurrent Futures API Interview Questions
• ThreadPoolExecutor Class API Cheat Sheet

I also recommend specific chapters from the following books:

• Effective Python, Brett Slatkin, 2019.
  • See Chapter 7: Concurrency and Parallelism
• Python in a Nutshell, Alex Martelli, et al., 2017.
  • See: Chapter: 14: Threads and Processes

Guides

• Python ThreadPoolExecutor: The Complete Guide
• Python ProcessPoolExecutor: The Complete Guide
• Python Threading: The Complete Guide
• Python ThreadPool: The Complete Guide

APIs

• concurrent.futures - Launching parallel tasks
• threading — Thread-based parallelism

References

• Thread (computing), Wikipedia.
• Futures and promises, Wikipedia.
• Thread pool, Wikipedia.

Takeaways

You now know how to kill running tasks in the ThreadPoolExecutor.

Do you have any questions?
Ask your questions in the comments below and I will do my best to answer.

Photo by Anton Savinov on Unsplash