blob: c2f92b305aab3eb64bea5e63fbb97bf8f0fa9a77 [file] [log] [blame]
Antoine Pitrou64a467d2010-12-12 20:34:49 +00001:mod:`concurrent.futures` --- Launching parallel tasks
2======================================================
Brian Quinlan81c4d362010-09-18 22:35:02 +00003
4.. module:: concurrent.futures
5 :synopsis: Execute computations concurrently using threads or processes.
6
Éric Araujo19f9b712011-08-19 00:49:18 +02007.. versionadded:: 3.2
8
Raymond Hettingera1993682011-01-27 01:20:32 +00009**Source code:** :source:`Lib/concurrent/futures/thread.py`
10and :source:`Lib/concurrent/futures/process.py`
11
Raymond Hettingera1993682011-01-27 01:20:32 +000012--------------
13
Brian Quinlan81c4d362010-09-18 22:35:02 +000014The :mod:`concurrent.futures` module provides a high-level interface for
15asynchronously executing callables.
16
Ezio Melottie130a522011-10-19 10:58:56 +030017The asynchronous execution can be performed with threads, using
Georg Brandlfb1720b2010-12-09 18:08:43 +000018:class:`ThreadPoolExecutor`, or separate processes, using
Georg Brandl035cedb2010-09-19 09:31:09 +000019:class:`ProcessPoolExecutor`. Both implement the same interface, which is
Brian Quinlan81c4d362010-09-18 22:35:02 +000020defined by the abstract :class:`Executor` class.
21
Georg Brandl035cedb2010-09-19 09:31:09 +000022
Brian Quinlan81c4d362010-09-18 22:35:02 +000023Executor Objects
Georg Brandl035cedb2010-09-19 09:31:09 +000024----------------
Brian Quinlan81c4d362010-09-18 22:35:02 +000025
Benjamin Petersonc713fc72010-09-19 04:23:17 +000026.. class:: Executor
Brian Quinlan81c4d362010-09-18 22:35:02 +000027
Georg Brandl035cedb2010-09-19 09:31:09 +000028 An abstract class that provides methods to execute calls asynchronously. It
Benjamin Petersonc713fc72010-09-19 04:23:17 +000029 should not be used directly, but through its concrete subclasses.
Brian Quinlan81c4d362010-09-18 22:35:02 +000030
31 .. method:: submit(fn, *args, **kwargs)
32
Benjamin Petersonc713fc72010-09-19 04:23:17 +000033 Schedules the callable, *fn*, to be executed as ``fn(*args **kwargs)``
34 and returns a :class:`Future` object representing the execution of the
Georg Brandl035cedb2010-09-19 09:31:09 +000035 callable. ::
Brian Quinlan81c4d362010-09-18 22:35:02 +000036
Georg Brandl035cedb2010-09-19 09:31:09 +000037 with ThreadPoolExecutor(max_workers=1) as executor:
38 future = executor.submit(pow, 323, 1235)
39 print(future.result())
Brian Quinlan81c4d362010-09-18 22:35:02 +000040
41 .. method:: map(func, *iterables, timeout=None)
42
Serhiy Storchaka9e0ae532013-08-24 00:23:38 +030043 Equivalent to :func:`map(func, *iterables) <map>` except *func* is executed
Georg Brandl035cedb2010-09-19 09:31:09 +000044 asynchronously and several calls to *func* may be made concurrently. The
Ezio Melotti7fa82222012-10-12 13:42:08 +030045 returned iterator raises a :exc:`TimeoutError` if
46 :meth:`~iterator.__next__` is called and the result isn't available
47 after *timeout* seconds from the original call to :meth:`Executor.map`.
48 *timeout* can be an int or a float. If *timeout* is not specified or
49 ``None``, there is no limit to the wait time. If a call raises an
50 exception, then that exception will be raised when its value is
51 retrieved from the iterator.
Brian Quinlan81c4d362010-09-18 22:35:02 +000052
53 .. method:: shutdown(wait=True)
54
55 Signal the executor that it should free any resources that it is using
Georg Brandl035cedb2010-09-19 09:31:09 +000056 when the currently pending futures are done executing. Calls to
Brian Quinlan81c4d362010-09-18 22:35:02 +000057 :meth:`Executor.submit` and :meth:`Executor.map` made after shutdown will
58 raise :exc:`RuntimeError`.
59
Benjamin Petersonc713fc72010-09-19 04:23:17 +000060 If *wait* is ``True`` then this method will not return until all the
Brian Quinlan81c4d362010-09-18 22:35:02 +000061 pending futures are done executing and the resources associated with the
Georg Brandl035cedb2010-09-19 09:31:09 +000062 executor have been freed. If *wait* is ``False`` then this method will
Benjamin Petersonc713fc72010-09-19 04:23:17 +000063 return immediately and the resources associated with the executor will be
Georg Brandl035cedb2010-09-19 09:31:09 +000064 freed when all pending futures are done executing. Regardless of the
Brian Quinlan81c4d362010-09-18 22:35:02 +000065 value of *wait*, the entire Python program will not exit until all
66 pending futures are done executing.
67
Georg Brandl035cedb2010-09-19 09:31:09 +000068 You can avoid having to call this method explicitly if you use the
69 :keyword:`with` statement, which will shutdown the :class:`Executor`
70 (waiting as if :meth:`Executor.shutdown` were called with *wait* set to
71 ``True``)::
Brian Quinlan81c4d362010-09-18 22:35:02 +000072
Georg Brandl035cedb2010-09-19 09:31:09 +000073 import shutil
74 with ThreadPoolExecutor(max_workers=4) as e:
75 e.submit(shutil.copy, 'src1.txt', 'dest1.txt')
76 e.submit(shutil.copy, 'src2.txt', 'dest2.txt')
77 e.submit(shutil.copy, 'src3.txt', 'dest3.txt')
78 e.submit(shutil.copy, 'src3.txt', 'dest4.txt')
Brian Quinlan81c4d362010-09-18 22:35:02 +000079
Brian Quinlan81c4d362010-09-18 22:35:02 +000080
81ThreadPoolExecutor
Georg Brandl035cedb2010-09-19 09:31:09 +000082------------------
Brian Quinlan81c4d362010-09-18 22:35:02 +000083
Benjamin Petersonc713fc72010-09-19 04:23:17 +000084:class:`ThreadPoolExecutor` is a :class:`Executor` subclass that uses a pool of
85threads to execute calls asynchronously.
Brian Quinlan81c4d362010-09-18 22:35:02 +000086
Benjamin Petersonc713fc72010-09-19 04:23:17 +000087Deadlocks can occur when the callable associated with a :class:`Future` waits on
Georg Brandl035cedb2010-09-19 09:31:09 +000088the results of another :class:`Future`. For example::
Brian Quinlan81c4d362010-09-18 22:35:02 +000089
Georg Brandl035cedb2010-09-19 09:31:09 +000090 import time
91 def wait_on_b():
92 time.sleep(5)
93 print(b.result()) # b will never complete because it is waiting on a.
94 return 5
Brian Quinlan81c4d362010-09-18 22:35:02 +000095
Georg Brandl035cedb2010-09-19 09:31:09 +000096 def wait_on_a():
97 time.sleep(5)
98 print(a.result()) # a will never complete because it is waiting on b.
99 return 6
Brian Quinlan81c4d362010-09-18 22:35:02 +0000100
101
Georg Brandl035cedb2010-09-19 09:31:09 +0000102 executor = ThreadPoolExecutor(max_workers=2)
103 a = executor.submit(wait_on_b)
104 b = executor.submit(wait_on_a)
Brian Quinlan81c4d362010-09-18 22:35:02 +0000105
Georg Brandl035cedb2010-09-19 09:31:09 +0000106And::
Brian Quinlan81c4d362010-09-18 22:35:02 +0000107
Georg Brandl035cedb2010-09-19 09:31:09 +0000108 def wait_on_future():
109 f = executor.submit(pow, 5, 2)
110 # This will never complete because there is only one worker thread and
111 # it is executing this function.
112 print(f.result())
Brian Quinlan81c4d362010-09-18 22:35:02 +0000113
Georg Brandl035cedb2010-09-19 09:31:09 +0000114 executor = ThreadPoolExecutor(max_workers=1)
115 executor.submit(wait_on_future)
Brian Quinlan81c4d362010-09-18 22:35:02 +0000116
117
118.. class:: ThreadPoolExecutor(max_workers)
119
120 An :class:`Executor` subclass that uses a pool of at most *max_workers*
121 threads to execute calls asynchronously.
122
Georg Brandl035cedb2010-09-19 09:31:09 +0000123
Brian Quinlan81c4d362010-09-18 22:35:02 +0000124.. _threadpoolexecutor-example:
125
126ThreadPoolExecutor Example
Georg Brandl035cedb2010-09-19 09:31:09 +0000127~~~~~~~~~~~~~~~~~~~~~~~~~~
Brian Quinlan81c4d362010-09-18 22:35:02 +0000128::
129
Georg Brandl035cedb2010-09-19 09:31:09 +0000130 import concurrent.futures
131 import urllib.request
Brian Quinlan81c4d362010-09-18 22:35:02 +0000132
Georg Brandl035cedb2010-09-19 09:31:09 +0000133 URLS = ['http://www.foxnews.com/',
134 'http://www.cnn.com/',
135 'http://europe.wsj.com/',
136 'http://www.bbc.co.uk/',
137 'http://some-made-up-domain.com/']
Brian Quinlan81c4d362010-09-18 22:35:02 +0000138
Nick Coghlanf06ea252012-10-16 22:50:04 +1000139 # Retrieve a single page and report the url and contents
Georg Brandl035cedb2010-09-19 09:31:09 +0000140 def load_url(url, timeout):
Nick Coghlanf06ea252012-10-16 22:50:04 +1000141 conn = urllib.request.urlopen(url, timeout=timeout)
142 return conn.readall()
Brian Quinlan81c4d362010-09-18 22:35:02 +0000143
Nick Coghlanf06ea252012-10-16 22:50:04 +1000144 # We can use a with statement to ensure threads are cleaned up promptly
Georg Brandl035cedb2010-09-19 09:31:09 +0000145 with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
Nick Coghlanf06ea252012-10-16 22:50:04 +1000146 # Start the load operations and mark each future with its URL
Georg Brandl0a1bc112013-03-23 15:59:46 +0100147 future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
Nick Coghland6d5cf32012-10-16 23:14:03 +1000148 for future in concurrent.futures.as_completed(future_to_url):
Nick Coghlan40c67732012-10-20 20:13:21 +1000149 url = future_to_url[future]
Nick Coghlanf06ea252012-10-16 22:50:04 +1000150 try:
151 data = future.result()
152 except Exception as exc:
153 print('%r generated an exception: %s' % (url, exc))
Georg Brandl035cedb2010-09-19 09:31:09 +0000154 else:
Nick Coghlanf06ea252012-10-16 22:50:04 +1000155 print('%r page is %d bytes' % (url, len(data)))
Brian Quinlan81c4d362010-09-18 22:35:02 +0000156
157
158ProcessPoolExecutor
Georg Brandl035cedb2010-09-19 09:31:09 +0000159-------------------
Brian Quinlan81c4d362010-09-18 22:35:02 +0000160
161The :class:`ProcessPoolExecutor` class is an :class:`Executor` subclass that
162uses a pool of processes to execute calls asynchronously.
163:class:`ProcessPoolExecutor` uses the :mod:`multiprocessing` module, which
164allows it to side-step the :term:`Global Interpreter Lock` but also means that
165only picklable objects can be executed and returned.
166
167Calling :class:`Executor` or :class:`Future` methods from a callable submitted
168to a :class:`ProcessPoolExecutor` will result in deadlock.
169
170.. class:: ProcessPoolExecutor(max_workers=None)
171
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000172 An :class:`Executor` subclass that executes calls asynchronously using a pool
Georg Brandl035cedb2010-09-19 09:31:09 +0000173 of at most *max_workers* processes. If *max_workers* is ``None`` or not
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000174 given, it will default to the number of processors on the machine.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000175
Antoine Pitroudd696492011-06-08 17:21:55 +0200176 .. versionchanged:: 3.3
177 When one of the worker processes terminates abruptly, a
178 :exc:`BrokenProcessPool` error is now raised. Previously, behaviour
179 was undefined but operations on the executor or its futures would often
180 freeze or deadlock.
181
Georg Brandl035cedb2010-09-19 09:31:09 +0000182
Brian Quinlan81c4d362010-09-18 22:35:02 +0000183.. _processpoolexecutor-example:
184
185ProcessPoolExecutor Example
Georg Brandl035cedb2010-09-19 09:31:09 +0000186~~~~~~~~~~~~~~~~~~~~~~~~~~~
Brian Quinlan81c4d362010-09-18 22:35:02 +0000187::
188
Georg Brandl035cedb2010-09-19 09:31:09 +0000189 import concurrent.futures
190 import math
Brian Quinlan81c4d362010-09-18 22:35:02 +0000191
Georg Brandl035cedb2010-09-19 09:31:09 +0000192 PRIMES = [
193 112272535095293,
194 112582705942171,
195 112272535095293,
196 115280095190773,
197 115797848077099,
198 1099726899285419]
Brian Quinlan81c4d362010-09-18 22:35:02 +0000199
Georg Brandl035cedb2010-09-19 09:31:09 +0000200 def is_prime(n):
201 if n % 2 == 0:
202 return False
Brian Quinlan81c4d362010-09-18 22:35:02 +0000203
Georg Brandl035cedb2010-09-19 09:31:09 +0000204 sqrt_n = int(math.floor(math.sqrt(n)))
205 for i in range(3, sqrt_n + 1, 2):
206 if n % i == 0:
207 return False
208 return True
Brian Quinlan81c4d362010-09-18 22:35:02 +0000209
Georg Brandl035cedb2010-09-19 09:31:09 +0000210 def main():
211 with concurrent.futures.ProcessPoolExecutor() as executor:
212 for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
213 print('%d is prime: %s' % (number, prime))
Brian Quinlan81c4d362010-09-18 22:35:02 +0000214
Georg Brandl035cedb2010-09-19 09:31:09 +0000215 if __name__ == '__main__':
216 main()
217
Brian Quinlan81c4d362010-09-18 22:35:02 +0000218
219Future Objects
Georg Brandl035cedb2010-09-19 09:31:09 +0000220--------------
Brian Quinlan81c4d362010-09-18 22:35:02 +0000221
Georg Brandl6faee4e2010-09-21 14:48:28 +0000222The :class:`Future` class encapsulates the asynchronous execution of a callable.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000223:class:`Future` instances are created by :meth:`Executor.submit`.
224
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000225.. class:: Future
Brian Quinlan81c4d362010-09-18 22:35:02 +0000226
Georg Brandl6faee4e2010-09-21 14:48:28 +0000227 Encapsulates the asynchronous execution of a callable. :class:`Future`
Brian Quinlan81c4d362010-09-18 22:35:02 +0000228 instances are created by :meth:`Executor.submit` and should not be created
229 directly except for testing.
230
231 .. method:: cancel()
232
Georg Brandl035cedb2010-09-19 09:31:09 +0000233 Attempt to cancel the call. If the call is currently being executed and
Eric Smith7b5011b2011-02-01 21:31:22 +0000234 cannot be cancelled then the method will return ``False``, otherwise the
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000235 call will be cancelled and the method will return ``True``.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000236
237 .. method:: cancelled()
238
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000239 Return ``True`` if the call was successfully cancelled.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000240
241 .. method:: running()
242
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000243 Return ``True`` if the call is currently being executed and cannot be
Brian Quinlan81c4d362010-09-18 22:35:02 +0000244 cancelled.
245
246 .. method:: done()
247
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000248 Return ``True`` if the call was successfully cancelled or finished
249 running.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000250
251 .. method:: result(timeout=None)
252
253 Return the value returned by the call. If the call hasn't yet completed
Georg Brandl035cedb2010-09-19 09:31:09 +0000254 then this method will wait up to *timeout* seconds. If the call hasn't
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000255 completed in *timeout* seconds, then a :exc:`TimeoutError` will be
Georg Brandl035cedb2010-09-19 09:31:09 +0000256 raised. *timeout* can be an int or float. If *timeout* is not specified
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000257 or ``None``, there is no limit to the wait time.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000258
259 If the future is cancelled before completing then :exc:`CancelledError`
260 will be raised.
261
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000262 If the call raised, this method will raise the same exception.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000263
264 .. method:: exception(timeout=None)
265
Georg Brandl035cedb2010-09-19 09:31:09 +0000266 Return the exception raised by the call. If the call hasn't yet
267 completed then this method will wait up to *timeout* seconds. If the
268 call hasn't completed in *timeout* seconds, then a :exc:`TimeoutError`
269 will be raised. *timeout* can be an int or float. If *timeout* is not
270 specified or ``None``, there is no limit to the wait time.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000271
272 If the future is cancelled before completing then :exc:`CancelledError`
273 will be raised.
274
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000275 If the call completed without raising, ``None`` is returned.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000276
277 .. method:: add_done_callback(fn)
278
Georg Brandl035cedb2010-09-19 09:31:09 +0000279 Attaches the callable *fn* to the future. *fn* will be called, with the
Brian Quinlan81c4d362010-09-18 22:35:02 +0000280 future as its only argument, when the future is cancelled or finishes
281 running.
282
283 Added callables are called in the order that they were added and are
Georg Brandl035cedb2010-09-19 09:31:09 +0000284 always called in a thread belonging to the process that added them. If
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000285 the callable raises a :exc:`Exception` subclass, it will be logged and
Georg Brandl035cedb2010-09-19 09:31:09 +0000286 ignored. If the callable raises a :exc:`BaseException` subclass, the
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000287 behavior is undefined.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000288
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000289 If the future has already completed or been cancelled, *fn* will be
Brian Quinlan81c4d362010-09-18 22:35:02 +0000290 called immediately.
291
292 The following :class:`Future` methods are meant for use in unit tests and
293 :class:`Executor` implementations.
294
295 .. method:: set_running_or_notify_cancel()
296
297 This method should only be called by :class:`Executor` implementations
Georg Brandl035cedb2010-09-19 09:31:09 +0000298 before executing the work associated with the :class:`Future` and by unit
299 tests.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000300
Senthil Kumaran916bd382010-10-15 12:55:19 +0000301 If the method returns ``False`` then the :class:`Future` was cancelled,
Georg Brandl035cedb2010-09-19 09:31:09 +0000302 i.e. :meth:`Future.cancel` was called and returned `True`. Any threads
303 waiting on the :class:`Future` completing (i.e. through
304 :func:`as_completed` or :func:`wait`) will be woken up.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000305
Senthil Kumaran916bd382010-10-15 12:55:19 +0000306 If the method returns ``True`` then the :class:`Future` was not cancelled
Georg Brandl035cedb2010-09-19 09:31:09 +0000307 and has been put in the running state, i.e. calls to
Brian Quinlan81c4d362010-09-18 22:35:02 +0000308 :meth:`Future.running` will return `True`.
309
310 This method can only be called once and cannot be called after
311 :meth:`Future.set_result` or :meth:`Future.set_exception` have been
312 called.
313
314 .. method:: set_result(result)
315
316 Sets the result of the work associated with the :class:`Future` to
317 *result*.
318
319 This method should only be used by :class:`Executor` implementations and
320 unit tests.
321
322 .. method:: set_exception(exception)
323
324 Sets the result of the work associated with the :class:`Future` to the
325 :class:`Exception` *exception*.
326
327 This method should only be used by :class:`Executor` implementations and
328 unit tests.
329
330
331Module Functions
Georg Brandl035cedb2010-09-19 09:31:09 +0000332----------------
Brian Quinlan81c4d362010-09-18 22:35:02 +0000333
334.. function:: wait(fs, timeout=None, return_when=ALL_COMPLETED)
335
336 Wait for the :class:`Future` instances (possibly created by different
Georg Brandl035cedb2010-09-19 09:31:09 +0000337 :class:`Executor` instances) given by *fs* to complete. Returns a named
338 2-tuple of sets. The first set, named ``done``, contains the futures that
339 completed (finished or were cancelled) before the wait completed. The second
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000340 set, named ``not_done``, contains uncompleted futures.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000341
342 *timeout* can be used to control the maximum number of seconds to wait before
Georg Brandl035cedb2010-09-19 09:31:09 +0000343 returning. *timeout* can be an int or float. If *timeout* is not specified
344 or ``None``, there is no limit to the wait time.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000345
Georg Brandl035cedb2010-09-19 09:31:09 +0000346 *return_when* indicates when this function should return. It must be one of
Brian Quinlan81c4d362010-09-18 22:35:02 +0000347 the following constants:
348
Georg Brandl44ea77b2013-03-28 13:28:44 +0100349 .. tabularcolumns:: |l|L|
350
Georg Brandl035cedb2010-09-19 09:31:09 +0000351 +-----------------------------+----------------------------------------+
352 | Constant | Description |
353 +=============================+========================================+
354 | :const:`FIRST_COMPLETED` | The function will return when any |
355 | | future finishes or is cancelled. |
356 +-----------------------------+----------------------------------------+
357 | :const:`FIRST_EXCEPTION` | The function will return when any |
358 | | future finishes by raising an |
359 | | exception. If no future raises an |
360 | | exception then it is equivalent to |
361 | | :const:`ALL_COMPLETED`. |
362 +-----------------------------+----------------------------------------+
363 | :const:`ALL_COMPLETED` | The function will return when all |
364 | | futures finish or are cancelled. |
365 +-----------------------------+----------------------------------------+
Brian Quinlan81c4d362010-09-18 22:35:02 +0000366
367.. function:: as_completed(fs, timeout=None)
368
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000369 Returns an iterator over the :class:`Future` instances (possibly created by
370 different :class:`Executor` instances) given by *fs* that yields futures as
Georg Brandl035cedb2010-09-19 09:31:09 +0000371 they complete (finished or were cancelled). Any futures that completed
372 before :func:`as_completed` is called will be yielded first. The returned
Ezio Melotti7fa82222012-10-12 13:42:08 +0300373 iterator raises a :exc:`TimeoutError` if :meth:`~iterator.__next__` is
374 called and the result isn't available after *timeout* seconds from the
375 original call to :func:`as_completed`. *timeout* can be an int or float.
376 If *timeout* is not specified or ``None``, there is no limit to the wait
377 time.
Georg Brandl035cedb2010-09-19 09:31:09 +0000378
379
380.. seealso::
381
382 :pep:`3148` -- futures - execute computations asynchronously
383 The proposal which described this feature for inclusion in the Python
384 standard library.
Antoine Pitroudd696492011-06-08 17:21:55 +0200385
386
387Exception classes
388-----------------
389
390.. exception:: BrokenProcessPool
391
392 Derived from :exc:`RuntimeError`, this exception class is raised when
393 one of the workers of a :class:`ProcessPoolExecutor` has terminated
394 in a non-clean fashion (for example, if it was killed from the outside).
395
396 .. versionadded:: 3.3
397