# `concurrent.futures` — Launching parallel tasks

Added in version 3.2.

Source code: Lib/concurrent/futures/thread.py, Lib/concurrent/futures/process.py, and Lib/concurrent/futures/interpreter.py

The `concurrent.futures` module provides a high-level interface for asynchronously executing callables.

The asynchronous execution can be performed with threads, using `ThreadPoolExecutor` or `InterpreterPoolExecutor`, or separate processes, using `ProcessPoolExecutor`. Each implements the same interface, which is defined by the abstract `Executor` class.

`concurrent.futures.Future` must not be confused with `asyncio.Future`, which is designed for use with `asyncio` tasks and coroutines. See the asyncio’s Future documentation for a detailed comparison of the two.

Availability: not WASI.

This module does not work or is not available on WebAssembly. See WebAssembly platforms for more information.

## Об’єкти виконавця

class concurrent.futures.Executor

  Абстрактний клас, який надає методи для асинхронного виконання викликів. Його слід використовувати не безпосередньо, а через його конкретні підкласи.

  submit(fn, /, *args, **kwargs)

    Планує виконання викликаного, fn, як `fn(*args, **kwargs)` і повертає об’єкт `Future`, який представляє виконання викликаного.

        with ThreadPoolExecutor(max_workers=1) as executor:
            future = executor.submit(pow, 323, 1235)
            print(future.result())

  map(fn, *iterables, timeout=None, chunksize=1, buffersize=None)

    Similar to `map(fn, *iterables)` except:

    - The iterables are collected immediately rather than lazily, unless a buffersize is specified to limit the number of submitted tasks whose results have not yet been yielded. If the buffer is full, iteration over the iterables pauses until a result is yielded from the buffer.

    - fn is executed asynchronously and several calls to fn may be made concurrently.

    The returned iterator raises a `TimeoutError` if `__next__()` is called and the result isn’t available after timeout seconds from the original call to `Executor.map()`. timeout can be an int or a float. If timeout is not specified or `None`, there is no limit to the wait time.

    If a fn call raises an exception, then that exception will be raised when its value is retrieved from the iterator.

    When using `ProcessPoolExecutor`, this method chops iterables into a number of chunks which it submits to the pool as separate tasks. The (approximate) size of these chunks can be specified by setting chunksize to a positive integer. For very long iterables, using a large value for chunksize can significantly improve performance compared to the default size of 1. With `ThreadPoolExecutor` and `InterpreterPoolExecutor`, chunksize has no effect.

    Змінено в версії 3.5: Added the chunksize parameter.

    Змінено в версії 3.14: Added the buffersize parameter.

  shutdown(wait=True, *, cancel_futures=False)

    Дайте сигнал виконавцю, що він повинен звільнити будь-які ресурси, які він використовує, коли завершено виконання поточних ф’ючерсів. Виклики `Executor.submit()` і `Executor.map()`, здійснені після вимкнення, викличуть `RuntimeError`.

    Якщо wait має значення `True`, тоді цей метод не повернеться, доки не буде завершено виконання всіх очікуваних ф’ючерсів і не буде звільнено ресурси, пов’язані з виконавцем. Якщо wait має значення `False`, тоді цей метод повернеться негайно, а ресурси, пов’язані з виконавцем, будуть звільнені, коли завершиться виконання всіх очікуваних ф’ючерсів. Незалежно від значення wait, уся програма Python не завершить роботу, доки не буде завершено виконання всіх незавершених ф’ючерсів.

    Якщо cancel_futures має значення `True`, цей метод скасує всі незавершені ф’ючерси, які виконавець ще не запускав. Будь-які завершені або запущені ф’ючерси не будуть скасовані, незалежно від значення cancel_futures.

    Якщо і cancel_futures, і wait мають значення `True`, усі ф’ючерси, які почав виконувати виконавець, будуть завершені до повернення цього методу. Решта ф’ючерсів скасовано.

    You can avoid having to call this method explicitly if you use the executor as a context manager via the `with` statement, which will shutdown the `Executor` (waiting as if `Executor.shutdown()` were called with wait set to `True`):

        import shutil
        with ThreadPoolExecutor(max_workers=4) as e:
            e.submit(shutil.copy, 'src1.txt', 'dest1.txt')
            e.submit(shutil.copy, 'src2.txt', 'dest2.txt')
            e.submit(shutil.copy, 'src3.txt', 'dest3.txt')
            e.submit(shutil.copy, 'src4.txt', 'dest4.txt')

    Змінено в версії 3.9: Додано cancel_futures.

## ThreadPoolExecutor

`ThreadPoolExecutor` — це підклас `Executor`, який використовує пул потоків для асинхронного виконання викликів.

Взаємоблокування можуть виникати, коли виклик, пов’язаний із `Future`, чекає результатів іншого `Future`. Наприклад:

    import time
    def wait_on_b():
        time.sleep(5)
        print(b.result())  # b will never complete because it is waiting on a.
        return 5

    def wait_on_a():
        time.sleep(5)
        print(a.result())  # a will never complete because it is waiting on b.
        return 6

    executor = ThreadPoolExecutor(max_workers=2)
    a = executor.submit(wait_on_b)
    b = executor.submit(wait_on_a)

І:

    def wait_on_future():
        f = executor.submit(pow, 5, 2)
        # This will never complete because there is only one worker thread and
        # it is executing this function.
        print(f.result())

    executor = ThreadPoolExecutor(max_workers=1)
    future = executor.submit(wait_on_future)
    # Note: calling future.result() would also cause a deadlock because
    # the single worker thread is already waiting for wait_on_future().

class concurrent.futures.ThreadPoolExecutor(max_workers=None, thread_name_prefix='', initializer=None, initargs=())

  Підклас `Executor`, який використовує пул щонайбільше max_workers потоків для асинхронного виконання викликів.

  All threads enqueued to `ThreadPoolExecutor` will be joined before the interpreter can exit. Note that the exit handler which does this is executed before any exit handlers added using `atexit`. This means exceptions in the main thread must be caught and handled in order to signal threads to exit gracefully. For this reason, it is recommended that `ThreadPoolExecutor` not be used for long-running tasks.

  initializer — необов’язковий виклик, який викликається на початку кожного робочого потоку; initargs — це кортеж аргументів, що передається ініціалізатору. Якщо ініціалізатор викликає виняток, усі наразі незавершені завдання викличуть `BrokenThreadPool`, а також будь-яка спроба відправити більше завдань до пулу.

  Змінено в версії 3.5: Якщо max_workers має значення `None` або не вказано, за замовчуванням буде використовуватися кількість процесорів на машині, помножена на `5`, припускаючи, що `ThreadPoolExecutor` часто використовується для перекриття вводу-виводу замість роботи центрального процесора, а кількість робітників має бути більшою за кількість робітників для `ProcessPoolExecutor`.

  Змінено в версії 3.6: Added the thread_name_prefix parameter to allow users to control the `threading.Thread` names for worker threads created by the pool for easier debugging.

  Змінено в версії 3.7: Додано аргументи initializer і initargs.

  Змінено в версії 3.8: Значення за замовчуванням max_workers змінено на `min(32, os.cpu_count() + 4)`. Це значення за замовчуванням зберігає принаймні 5 працівників для завдань, пов’язаних із вводом-виводом. Він використовує щонайбільше 32 ядра ЦП для пов’язаних із ЦП завдань, які випускають GIL. І це дозволяє уникнути використання дуже великих ресурсів неявно на багатоядерних машинах.

  ThreadPoolExecutor тепер повторно використовує неактивні робочі потоки перед запуском робочих потоків max_workers.

  Змінено в версії 3.13: Default value of max_workers is changed to `min(32, (os.process_cpu_count() or 1) + 4)`.

### Приклад ThreadPoolExecutor

    import concurrent.futures
    import urllib.request

    URLS = ['http://www.foxnews.com/',
            'http://www.cnn.com/',
            'http://europe.wsj.com/',
            'http://www.bbc.co.uk/',
            'http://nonexistent-subdomain.python.org/']

    # Retrieve a single page and report the URL and contents
    def load_url(url, timeout):
        with urllib.request.urlopen(url, timeout=timeout) as conn:
            return conn.read()

    # We can use a with statement to ensure threads are cleaned up promptly
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        # Start the load operations and mark each future with its URL
        future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
        for future in concurrent.futures.as_completed(future_to_url):
            url = future_to_url[future]
            try:
                data = future.result()
            except Exception as exc:
                print('%r generated an exception: %s' % (url, exc))
            else:
                print('%r page is %d bytes' % (url, len(data)))

## InterpreterPoolExecutor

Added in version 3.14.

The `InterpreterPoolExecutor` class uses a pool of interpreters to execute calls asynchronously. It is a `ThreadPoolExecutor` subclass, which means each worker is running in its own thread. The difference here is that each worker has its own interpreter, and runs each task using that interpreter.

The biggest benefit to using interpreters instead of only threads is true multi-core parallelism. Each interpreter has its own Global Interpreter Lock, so code running in one interpreter can run on one CPU core, while code in another interpreter runs unblocked on a different core.

The tradeoff is that writing concurrent code for use with multiple interpreters can take extra effort. However, this is because it forces you to be deliberate about how and when interpreters interact, and to be explicit about what data is shared between interpreters. This results in several benefits that help balance the extra effort, including true multi-core parallelism, For example, code written this way can make it easier to reason about concurrency. Another major benefit is that you don’t have to deal with several of the big pain points of using threads, like race conditions.

Each worker’s interpreter is isolated from all the other interpreters. «Isolated» means each interpreter has its own runtime state and operates completely independently. For example, if you redirect `sys.stdout` in one interpreter, it will not be automatically redirected to any other interpreter. If you import a module in one interpreter, it is not automatically imported in any other. You would need to import the module separately in interpreter where you need it. In fact, each module imported in an interpreter is a completely separate object from the same module in a different interpreter, including `sys`, `builtins`, and even `__main__`.

Isolation means a mutable object, or other data, cannot be used by more than one interpreter at the same time. That effectively means interpreters cannot actually share such objects or data. Instead, each interpreter must have its own copy, and you will have to synchronize any changes between the copies manually. Immutable objects and data, like the builtin singletons, strings, and tuples of immutable objects, don’t have these limitations.

Communicating and synchronizing between interpreters is most effectively done using dedicated tools, like those proposed in PEP 734. One less efficient alternative is to serialize with `pickle` and then send the bytes over a shared `socket` or `pipe`.

class concurrent.futures.InterpreterPoolExecutor(max_workers=None, thread_name_prefix='', initializer=None, initargs=())

  A `ThreadPoolExecutor` subclass that executes calls asynchronously using a pool of at most max_workers threads. Each thread runs tasks in its own interpreter. The worker interpreters are isolated from each other, which means each has its own runtime state and that they can’t share any mutable objects or other data. Each interpreter has its own Global Interpreter Lock, which means code run with this executor has true multi-core parallelism.

  The optional initializer and initargs arguments have the same meaning as for `ThreadPoolExecutor`: the initializer is run when each worker is created, though in this case it is run in the worker’s interpreter. The executor serializes the initializer and initargs using `pickle` when sending them to the worker’s interpreter.

  Примітка

  The executor may replace uncaught exceptions from initializer with `ExecutionFailed`.

  Other caveats from parent `ThreadPoolExecutor` apply here.

`submit()` and `map()` work like normal, except the worker serializes the callable and arguments using `pickle` when sending them to its interpreter. The worker likewise serializes the return value when sending it back.

When a worker’s current task raises an uncaught exception, the worker always tries to preserve the exception as-is. If that is successful then it also sets the `__cause__` to a corresponding `ExecutionFailed` instance, which contains a summary of the original exception. In the uncommon case that the worker is not able to preserve the original as-is then it directly preserves the corresponding `ExecutionFailed` instance instead.

## ProcessPoolExecutor

Клас `ProcessPoolExecutor` є підкласом `Executor`, який використовує пул процесів для асинхронного виконання викликів. `ProcessPoolExecutor` використовує модуль `multiprocessing`, який дозволяє йому обходити Global Interpreter Lock, але також означає, що можна виконувати та повертати лише об’єкти, які можна вибрати.

Модуль `__main__` має бути імпортованим робочими підпроцесами. Це означає, що `ProcessPoolExecutor` не працюватиме в інтерактивному інтерпретаторі.

Виклик методів `Executor` або `Future` із виклику, надісланого до `ProcessPoolExecutor`, призведе до взаємоблокування.

Note that the restrictions on functions and arguments needing to picklable as per `multiprocessing.Process` apply when using `submit()` and `map()` on a `ProcessPoolExecutor`. A function defined in a REPL or a lambda should not be expected to work.

class concurrent.futures.ProcessPoolExecutor(max_workers=None, mp_context=None, initializer=None, initargs=(), max_tasks_per_child=None)

  An `Executor` subclass that executes calls asynchronously using a pool of at most max_workers processes. If max_workers is `None` or not given, it will default to `os.process_cpu_count()`. If max_workers is less than or equal to `0`, then a `ValueError` will be raised. On Windows, max_workers must be less than or equal to `61`. If it is not then `ValueError` will be raised. If max_workers is `None`, then the default chosen will be at most `61`, even if more processors are available. mp_context can be a `multiprocessing` context or `None`. It will be used to launch the workers. If mp_context is `None` or not given, the default `multiprocessing` context is used. See Контексти та методи запуску.

  initializer — необов’язковий виклик, який викликається на початку кожного робочого процесу; initargs — це кортеж аргументів, що передається ініціалізатору. Якщо ініціалізатор викличе виняток, усі наразі незавершені завдання викличуть `BrokenProcessPool`, а також будь-яка спроба надіслати більше завдань до пулу.

  max_tasks_per_child is an optional argument that specifies the maximum number of tasks a single process can execute before it will exit and be replaced with a fresh worker process. By default max_tasks_per_child is `None` which means worker processes will live as long as the pool. When a max is specified, the «spawn» multiprocessing start method will be used by default in absence of a mp_context parameter. This feature is incompatible with the «fork» start method.

  Примітка

  Bugs have been reported when using the max_tasks_per_child feature that can result in the `ProcessPoolExecutor` hanging in some circumstances. Follow its eventual resolution in gh-115634.

  Змінено в версії 3.3: When one of the worker processes terminates abruptly, a `BrokenProcessPool` error is now raised. Previously, behaviour was undefined but operations on the executor or its futures would often freeze or deadlock.

  Змінено в версії 3.7: Аргумент mp_context додано, щоб дозволити користувачам керувати start_method для робочих процесів, створених пулом.

  Додано аргументи initializer і initargs.

  Змінено в версії 3.11: The max_tasks_per_child argument was added to allow users to control the lifetime of workers in the pool.

  Змінено в версії 3.12: On POSIX systems, if your application has multiple threads and the `multiprocessing` context uses the `"fork"` start method: The `os.fork()` function called internally to spawn workers may raise a `DeprecationWarning`. Pass a mp_context configured to use a different start method. See the `os.fork()` documentation for further explanation.

  Змінено в версії 3.13: max_workers uses `os.process_cpu_count()` by default, instead of `os.cpu_count()`.

  Змінено в версії 3.14: The default process start method (see Контексти та методи запуску) changed away from fork. If you require the fork start method for `ProcessPoolExecutor` you must explicitly pass `mp_context=multiprocessing.get_context("fork")`.

  terminate_workers()

    Attempt to terminate all living worker processes immediately by calling `Process.terminate` on each of them. Internally, it will also call `Executor.shutdown()` to ensure that all other resources associated with the executor are freed.

    After calling this method the caller should no longer submit tasks to the executor.

    Added in version 3.14.

  kill_workers()

    Attempt to kill all living worker processes immediately by calling `Process.kill` on each of them. Internally, it will also call `Executor.shutdown()` to ensure that all other resources associated with the executor are freed.

    After calling this method the caller should no longer submit tasks to the executor.

    Added in version 3.14.

### Приклад ProcessPoolExecutor

    import concurrent.futures
    import math

    PRIMES = [
        112272535095293,
        112582705942171,
        112272535095293,
        115280095190773,
        115797848077099,
        1099726899285419]

    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False

        sqrt_n = int(math.floor(math.sqrt(n)))
        for i in range(3, sqrt_n + 1, 2):
            if n % i == 0:
                return False
        return True

    def main():
        with concurrent.futures.ProcessPoolExecutor() as executor:
            for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
                print('%d is prime: %s' % (number, prime))

    if __name__ == '__main__':
        main()

## Об’єкти майбутнього

Клас `Future` інкапсулює асинхронне виконання викликаного. `Future` екземпляри створюються `Executor.submit()`.

class concurrent.futures.Future

  Інкапсулює асинхронне виконання викликаного. `Future` екземпляри створюються `Executor.submit()` і не повинні створюватися безпосередньо, за винятком тестування.

  cancel()

    Спроба скасувати виклик. Якщо виклик наразі виконується або завершується і його не можна скасувати, тоді метод поверне `False`, інакше виклик буде скасовано, а метод поверне `True`.

  cancelled()

    Повертає `True`, якщо виклик було успішно скасовано.

  running()

    Повертає `True`, якщо виклик зараз виконується і не може бути скасований.

  done()

    Повертає `True`, якщо виклик було успішно скасовано або завершено.

  result(timeout=None)

    Return 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. timeout can be an int or float. If timeout is not specified or `None`, there is no limit to the wait time.

    Якщо ф’ючерс скасовано до завершення, тоді буде викликано `CancelledError`.

    Якщо виклик викликав виняток, цей метод викличе той самий виняток.

  exception(timeout=None)

    Return the exception raised 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. timeout can be an int or float. If timeout is not specified or `None`, there is no limit to the wait time.

    Якщо ф’ючерс скасовано до завершення, тоді буде викликано `CancelledError`.

    Якщо виклик завершився без підняття, повертається `None`.

  add_done_callback(fn)

    Приєднує fn до майбутнього. fn буде викликано з майбутнім як єдиним аргументом, коли майбутнє скасовується або завершує роботу.

    Додані виклики викликаються в тому порядку, в якому вони були додані, і завжди викликаються в потоці, що належить до процесу, який їх додав. Якщо виклик викликає підклас `Exception`, він буде зареєстрований і проігнорований. Якщо виклик викликає підклас `BaseException`, поведінка не визначена.

    Якщо ф’ючерс уже завершено або скасовано, fn буде викликано негайно.

  Наступні методи `Future` призначені для використання в модульних тестах і реалізаціях `Executor`.

  set_running_or_notify_cancel()

    Цей метод має викликатися лише реалізаціями `Executor` перед виконанням роботи, пов’язаної з `Future` і модульними тестами.

    If the method returns `False` then the `Future` was cancelled, i.e. `Future.cancel()` was called and returned `True`. Any threads waiting on the `Future` completing (i.e. through `as_completed()` or `wait()`) will be woken up.

    If the method returns `True` then the `Future` was not cancelled and has been put in the running state, i.e. calls to `Future.running()` will return `True`.

    Цей метод можна викликати лише один раз і не можна викликати після виклику `Future.set_result()` або `Future.set_exception()`.

  set_result(result)

    Встановлює для результату роботи, пов’язаної з `Future` значення result.

    Цей метод має використовуватися лише реалізаціями `Executor` і модульними тестами.

    Змінено в версії 3.8: Цей метод викликає `concurrent.futures.InvalidStateError`, якщо `Future` вже виконано.

  set_exception(exception)

    Встановлює для результату роботи, пов’язаної з `Future` значення `Exception` виняток.

    Цей метод має використовуватися лише реалізаціями `Executor` і модульними тестами.

    Змінено в версії 3.8: Цей метод викликає `concurrent.futures.InvalidStateError`, якщо `Future` вже виконано.

## Функції модуля

concurrent.futures.wait(fs, timeout=None, return_when=ALL_COMPLETED)

  Зачекайте, доки екземпляри `Future` (можливо, створені різними екземплярами `Executor`), надані fs, завершаться. Подвійні ф’ючерси, надані fs, видаляються та повертаються лише один раз. Повертає іменований 2-кортеж наборів. Перший набір, названий `done`, містить ф’ючерси, які завершилися (завершені або скасовані ф’ючерси) до завершення очікування. Другий набір під назвою `not_done` містить ф’ючерси, які не завершилися (ф’ючерси, що очікують або виконуються).

  timeout можна використовувати для контролю максимальної кількості секунд очікування перед поверненням. timeout може бути int або float. Якщо timeout не вказано або `None`, час очікування не обмежений.

  return_when вказує, коли ця функція має повернутися. Це має бути одна з таких констант:

  Постійний | опис
  --- | ---
  concurrent.futures.FIRST_COMPLETED | Функція повернеться, коли будь-який майбутній завершиться або буде скасовано.
  concurrent.futures.FIRST_EXCEPTION | The function will return when any future finishes by raising an exception. If no future raises an exception then it is equivalent to `ALL_COMPLETED`.
  concurrent.futures.ALL_COMPLETED | Функція повернеться, коли всі ф’ючерси закінчаться або будуть скасовані.

concurrent.futures.as_completed(fs, timeout=None)

  Returns an iterator over the `Future` instances (possibly created by different `Executor` instances) given by fs that yields futures as they complete (finished or cancelled futures). Any futures given by fs that are duplicated will be returned once. Any futures that completed before `as_completed()` is called will be yielded first. The returned iterator raises a `TimeoutError` if `__next__()` is called and the result isn’t available after timeout seconds from the original call to `as_completed()`. timeout can be an int or float. If timeout is not specified or `None`, there is no limit to the wait time.

Дивись також

PEP 3148 – ф’ючерси - виконувати обчислення асинхронно

  Пропозиція, яка описує цю функцію для включення в стандартну бібліотеку Python.

## Класи винятків

exception concurrent.futures.CancelledError

  Піднімається, коли ф’ючерс скасовується.

exception concurrent.futures.TimeoutError

  A deprecated alias of `TimeoutError`, raised when a future operation exceeds the given timeout.

  Змінено в версії 3.11: Цей клас отримав псевдонім `TimeoutError`.

exception concurrent.futures.BrokenExecutor

  Похідний від `RuntimeError`, цей клас винятків виникає, коли виконавець з певної причини не працює, і його не можна використовувати для надсилання або виконання нових завдань.

  Added in version 3.7.

exception concurrent.futures.InvalidStateError

  Викликається, коли над майбутнім виконується операція, яка не дозволена в поточному стані.

  Added in version 3.8.

exception concurrent.futures.thread.BrokenThreadPool

  Derived from `BrokenExecutor`, this exception class is raised when one of the workers of a `ThreadPoolExecutor` has failed initializing.

  Added in version 3.7.

exception concurrent.futures.interpreter.BrokenInterpreterPool

  Derived from `BrokenThreadPool`, this exception class is raised when one of the workers of a `InterpreterPoolExecutor` has failed initializing.

  Added in version 3.14.

exception concurrent.futures.process.BrokenProcessPool

  Derived from `BrokenExecutor` (formerly `RuntimeError`), this exception class is raised when one of the workers of a `ProcessPoolExecutor` has terminated in a non-clean fashion (for example, if it was killed from the outside).

  Added in version 3.3.