blob: 48b43628b56738cca45b255428a81e8d613b09e4 [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):
Berker Peksag9575e182015-04-12 13:52:49 +0300141 with urllib.request.urlopen(url, timeout=timeout) as conn:
142 return conn.read()
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
bquinlan7749cb52013-10-26 04:49:55 +1100167The ``__main__`` module must be importable by worker subprocesses. This means
168that :class:`ProcessPoolExecutor` will not work in the interactive interpreter.
169
Brian Quinlan81c4d362010-09-18 22:35:02 +0000170Calling :class:`Executor` or :class:`Future` methods from a callable submitted
171to a :class:`ProcessPoolExecutor` will result in deadlock.
172
173.. class:: ProcessPoolExecutor(max_workers=None)
174
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000175 An :class:`Executor` subclass that executes calls asynchronously using a pool
Georg Brandl035cedb2010-09-19 09:31:09 +0000176 of at most *max_workers* processes. If *max_workers* is ``None`` or not
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000177 given, it will default to the number of processors on the machine.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000178
Antoine Pitroudd696492011-06-08 17:21:55 +0200179 .. versionchanged:: 3.3
180 When one of the worker processes terminates abruptly, a
181 :exc:`BrokenProcessPool` error is now raised. Previously, behaviour
182 was undefined but operations on the executor or its futures would often
183 freeze or deadlock.
184
Georg Brandl035cedb2010-09-19 09:31:09 +0000185
Brian Quinlan81c4d362010-09-18 22:35:02 +0000186.. _processpoolexecutor-example:
187
188ProcessPoolExecutor Example
Georg Brandl035cedb2010-09-19 09:31:09 +0000189~~~~~~~~~~~~~~~~~~~~~~~~~~~
Brian Quinlan81c4d362010-09-18 22:35:02 +0000190::
191
Georg Brandl035cedb2010-09-19 09:31:09 +0000192 import concurrent.futures
193 import math
Brian Quinlan81c4d362010-09-18 22:35:02 +0000194
Georg Brandl035cedb2010-09-19 09:31:09 +0000195 PRIMES = [
196 112272535095293,
197 112582705942171,
198 112272535095293,
199 115280095190773,
200 115797848077099,
201 1099726899285419]
Brian Quinlan81c4d362010-09-18 22:35:02 +0000202
Georg Brandl035cedb2010-09-19 09:31:09 +0000203 def is_prime(n):
204 if n % 2 == 0:
205 return False
Brian Quinlan81c4d362010-09-18 22:35:02 +0000206
Georg Brandl035cedb2010-09-19 09:31:09 +0000207 sqrt_n = int(math.floor(math.sqrt(n)))
208 for i in range(3, sqrt_n + 1, 2):
209 if n % i == 0:
210 return False
211 return True
Brian Quinlan81c4d362010-09-18 22:35:02 +0000212
Georg Brandl035cedb2010-09-19 09:31:09 +0000213 def main():
214 with concurrent.futures.ProcessPoolExecutor() as executor:
215 for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
216 print('%d is prime: %s' % (number, prime))
Brian Quinlan81c4d362010-09-18 22:35:02 +0000217
Georg Brandl035cedb2010-09-19 09:31:09 +0000218 if __name__ == '__main__':
219 main()
220
Brian Quinlan81c4d362010-09-18 22:35:02 +0000221
222Future Objects
Georg Brandl035cedb2010-09-19 09:31:09 +0000223--------------
Brian Quinlan81c4d362010-09-18 22:35:02 +0000224
Georg Brandl6faee4e2010-09-21 14:48:28 +0000225The :class:`Future` class encapsulates the asynchronous execution of a callable.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000226:class:`Future` instances are created by :meth:`Executor.submit`.
227
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000228.. class:: Future
Brian Quinlan81c4d362010-09-18 22:35:02 +0000229
Georg Brandl6faee4e2010-09-21 14:48:28 +0000230 Encapsulates the asynchronous execution of a callable. :class:`Future`
Brian Quinlan81c4d362010-09-18 22:35:02 +0000231 instances are created by :meth:`Executor.submit` and should not be created
232 directly except for testing.
233
234 .. method:: cancel()
235
Georg Brandl035cedb2010-09-19 09:31:09 +0000236 Attempt to cancel the call. If the call is currently being executed and
Eric Smith7b5011b2011-02-01 21:31:22 +0000237 cannot be cancelled then the method will return ``False``, otherwise the
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000238 call will be cancelled and the method will return ``True``.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000239
240 .. method:: cancelled()
241
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000242 Return ``True`` if the call was successfully cancelled.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000243
244 .. method:: running()
245
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000246 Return ``True`` if the call is currently being executed and cannot be
Brian Quinlan81c4d362010-09-18 22:35:02 +0000247 cancelled.
248
249 .. method:: done()
250
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000251 Return ``True`` if the call was successfully cancelled or finished
252 running.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000253
254 .. method:: result(timeout=None)
255
256 Return the value returned by the call. If the call hasn't yet completed
Georg Brandl035cedb2010-09-19 09:31:09 +0000257 then this method will wait up to *timeout* seconds. If the call hasn't
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000258 completed in *timeout* seconds, then a :exc:`TimeoutError` will be
Georg Brandl035cedb2010-09-19 09:31:09 +0000259 raised. *timeout* can be an int or float. If *timeout* is not specified
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000260 or ``None``, there is no limit to the wait time.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000261
262 If the future is cancelled before completing then :exc:`CancelledError`
263 will be raised.
264
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000265 If the call raised, this method will raise the same exception.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000266
267 .. method:: exception(timeout=None)
268
Georg Brandl035cedb2010-09-19 09:31:09 +0000269 Return the exception raised by the call. If the call hasn't yet
270 completed then this method will wait up to *timeout* seconds. If the
271 call hasn't completed in *timeout* seconds, then a :exc:`TimeoutError`
272 will be raised. *timeout* can be an int or float. If *timeout* is not
273 specified or ``None``, there is no limit to the wait time.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000274
275 If the future is cancelled before completing then :exc:`CancelledError`
276 will be raised.
277
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000278 If the call completed without raising, ``None`` is returned.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000279
280 .. method:: add_done_callback(fn)
281
Georg Brandl035cedb2010-09-19 09:31:09 +0000282 Attaches the callable *fn* to the future. *fn* will be called, with the
Brian Quinlan81c4d362010-09-18 22:35:02 +0000283 future as its only argument, when the future is cancelled or finishes
284 running.
285
286 Added callables are called in the order that they were added and are
Georg Brandl035cedb2010-09-19 09:31:09 +0000287 always called in a thread belonging to the process that added them. If
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000288 the callable raises a :exc:`Exception` subclass, it will be logged and
Georg Brandl035cedb2010-09-19 09:31:09 +0000289 ignored. If the callable raises a :exc:`BaseException` subclass, the
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000290 behavior is undefined.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000291
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000292 If the future has already completed or been cancelled, *fn* will be
Brian Quinlan81c4d362010-09-18 22:35:02 +0000293 called immediately.
294
295 The following :class:`Future` methods are meant for use in unit tests and
296 :class:`Executor` implementations.
297
298 .. method:: set_running_or_notify_cancel()
299
300 This method should only be called by :class:`Executor` implementations
Georg Brandl035cedb2010-09-19 09:31:09 +0000301 before executing the work associated with the :class:`Future` and by unit
302 tests.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000303
Senthil Kumaran916bd382010-10-15 12:55:19 +0000304 If the method returns ``False`` then the :class:`Future` was cancelled,
Georg Brandl035cedb2010-09-19 09:31:09 +0000305 i.e. :meth:`Future.cancel` was called and returned `True`. Any threads
306 waiting on the :class:`Future` completing (i.e. through
307 :func:`as_completed` or :func:`wait`) will be woken up.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000308
Senthil Kumaran916bd382010-10-15 12:55:19 +0000309 If the method returns ``True`` then the :class:`Future` was not cancelled
Georg Brandl035cedb2010-09-19 09:31:09 +0000310 and has been put in the running state, i.e. calls to
Brian Quinlan81c4d362010-09-18 22:35:02 +0000311 :meth:`Future.running` will return `True`.
312
313 This method can only be called once and cannot be called after
314 :meth:`Future.set_result` or :meth:`Future.set_exception` have been
315 called.
316
317 .. method:: set_result(result)
318
319 Sets the result of the work associated with the :class:`Future` to
320 *result*.
321
322 This method should only be used by :class:`Executor` implementations and
323 unit tests.
324
325 .. method:: set_exception(exception)
326
327 Sets the result of the work associated with the :class:`Future` to the
328 :class:`Exception` *exception*.
329
330 This method should only be used by :class:`Executor` implementations and
331 unit tests.
332
333
334Module Functions
Georg Brandl035cedb2010-09-19 09:31:09 +0000335----------------
Brian Quinlan81c4d362010-09-18 22:35:02 +0000336
337.. function:: wait(fs, timeout=None, return_when=ALL_COMPLETED)
338
339 Wait for the :class:`Future` instances (possibly created by different
Georg Brandl035cedb2010-09-19 09:31:09 +0000340 :class:`Executor` instances) given by *fs* to complete. Returns a named
341 2-tuple of sets. The first set, named ``done``, contains the futures that
342 completed (finished or were cancelled) before the wait completed. The second
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000343 set, named ``not_done``, contains uncompleted futures.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000344
345 *timeout* can be used to control the maximum number of seconds to wait before
Georg Brandl035cedb2010-09-19 09:31:09 +0000346 returning. *timeout* can be an int or float. If *timeout* is not specified
347 or ``None``, there is no limit to the wait time.
Brian Quinlan81c4d362010-09-18 22:35:02 +0000348
Georg Brandl035cedb2010-09-19 09:31:09 +0000349 *return_when* indicates when this function should return. It must be one of
Brian Quinlan81c4d362010-09-18 22:35:02 +0000350 the following constants:
351
Georg Brandl44ea77b2013-03-28 13:28:44 +0100352 .. tabularcolumns:: |l|L|
353
Georg Brandl035cedb2010-09-19 09:31:09 +0000354 +-----------------------------+----------------------------------------+
355 | Constant | Description |
356 +=============================+========================================+
357 | :const:`FIRST_COMPLETED` | The function will return when any |
358 | | future finishes or is cancelled. |
359 +-----------------------------+----------------------------------------+
360 | :const:`FIRST_EXCEPTION` | The function will return when any |
361 | | future finishes by raising an |
362 | | exception. If no future raises an |
363 | | exception then it is equivalent to |
364 | | :const:`ALL_COMPLETED`. |
365 +-----------------------------+----------------------------------------+
366 | :const:`ALL_COMPLETED` | The function will return when all |
367 | | futures finish or are cancelled. |
368 +-----------------------------+----------------------------------------+
Brian Quinlan81c4d362010-09-18 22:35:02 +0000369
370.. function:: as_completed(fs, timeout=None)
371
Benjamin Petersonc713fc72010-09-19 04:23:17 +0000372 Returns an iterator over the :class:`Future` instances (possibly created by
373 different :class:`Executor` instances) given by *fs* that yields futures as
Guido van Rossume6994ff2014-01-26 09:57:51 -0800374 they complete (finished or were cancelled). Any futures given by *fs* that
375 are duplicated will be returned once. Any futures that completed
Georg Brandl035cedb2010-09-19 09:31:09 +0000376 before :func:`as_completed` is called will be yielded first. The returned
Ezio Melotti7fa82222012-10-12 13:42:08 +0300377 iterator raises a :exc:`TimeoutError` if :meth:`~iterator.__next__` is
378 called and the result isn't available after *timeout* seconds from the
379 original call to :func:`as_completed`. *timeout* can be an int or float.
380 If *timeout* is not specified or ``None``, there is no limit to the wait
381 time.
Georg Brandl035cedb2010-09-19 09:31:09 +0000382
383
384.. seealso::
385
386 :pep:`3148` -- futures - execute computations asynchronously
387 The proposal which described this feature for inclusion in the Python
388 standard library.
Antoine Pitroudd696492011-06-08 17:21:55 +0200389
390
391Exception classes
392-----------------
393
Georg Brandlce64ced2014-10-28 22:58:24 +0100394.. currentmodule:: concurrent.futures.process
395
Antoine Pitroudd696492011-06-08 17:21:55 +0200396.. exception:: BrokenProcessPool
397
398 Derived from :exc:`RuntimeError`, this exception class is raised when
399 one of the workers of a :class:`ProcessPoolExecutor` has terminated
400 in a non-clean fashion (for example, if it was killed from the outside).
401
402 .. versionadded:: 3.3
403