Структура Task.

Она содержит следующие поля:

• :mfa - кортеж из трех элементов, содержащий модуль, имя функции и арность, вызваные для запуска задачи в async/1 и async/3

• :owner - PID процесса, который запустил задачу

• :pid - PID процесса задачи; nil если для задачи не назначен конкретный процесс

• :ref - неявное значение, используемое в качестве ссылки на монитор задачи

@spec async((-> any())) :: t()

Запускает задачу, за которой необходимо следить.

fun должна быть анонимной функцией нулевой арности. Эта функция порождает процесс, связанный и отслеживаемый процессом-вызывающим. Возвращается структура Task, содержащая соответствующую информацию.

Если вы запускаете async, вы должны дождаться её завершения. Это делается путем вызова Task.await/2 или Task.yield/2, за которым следует Task.shutdown/2 на возвращенной задаче. В качестве альтернативы, если вы порождаете задачу внутри GenServer, то GenServer автоматически дождется результата и вызовет GenServer.handle_info/2 с ответом задачи и связанным с ней :DOWN сообщением.

Прочитайте документацию модуля Task для получения дополнительной информации об общем использовании асинхронных задач.

Связывание

Эта функция порождает процесс, связанный и отслеживаемый вызывающим процессом. Часть со связыванием важна, потому что она прерывает задачу, если родительский процесс погибает. Она также гарантирует, что код до async/await обладает теми же свойствами после добавления асинхронного вызова. Например, представьте, что у вас есть следующее:

x = heavy_fun()
y = some_fun()
x + y

Теперь вы хотите сделать heavy_fun() асинхронным:

x = Task.async(&heavy_fun/0)
y = some_fun()
Task.await(x) + y

Как и прежде, если heavy_fun/0 завершается неудачно, вся вычисления завершатся неудачей, включая вызывающий процесс. Если вы не хотите, чтобы задача завершилась неудачей, вы должны изменить код heavy_fun/0 таким же образом, как вы бы это сделали, если бы у вас не было асинхронного вызова. Например, либо вернуть {:ok, val} | :error результаты, или, в более крайних случаях, используя try/rescue. Другими словами, асинхронная задача должна рассматриваться как расширение вызывающего процесса, а не как механизм для изоляции его от всех ошибок.

Если вы не хотите связывать вызывающий процесс с задачей, то вы должны использовать контролируемую задачу с Task.Supervisor и вызвать Task.Supervisor.async_nolink/2.

В любом случае, избегайте следующего:

• Установку :trap_exit на true - отлов выхода должен использоваться только в особых случаях, так как это сделает ваш процесс неуязвимым не только для выхода из задачи, но и для любого другого процесса.

  Более того, даже при отлове выходов, вызов await все равно завершится неудачей, если задача завершилась без возврата своего результата.

• Отключение связи процесса задачи, запущенного с помощью async/await. Если вы отключаете связь процессов, и задача не принадлежит ни одному супервайзеру, вы можете оставить висящие задачи в случае смерти вызывающего процесса.

Метаданные

Созданная с помощью этой функции задача хранит :erlang.apply/2 в поле метаданных :mfa, которое используется внутри для применения анонимной функции. Используйте async/3, если вы хотите использовать другую функцию в качестве метаданных.

@spec async(module(), atom(), [term()]) :: t()

Запускает задачу, за которой необходимо следить.

Аналогично async/1, за исключением того, что функция, которая будет запущена, задается указанными module, function_name, и args. module, function_name, и ее арность хранятся в виде кортежа в поле :mfa для целей отражения.

@spec async_stream(Enumerable.t(), (term() -> term()), [async_stream_option()]) ::
  Enumerable.t()

Возвращает поток, который выполняет заданную функцию fun асинхронно для каждого элемента в enumerable.

Работает так же, как async_stream/5, но с анонимной функцией вместо кортежа модуль-функция-аргументы. fun должна быть анонимной функцией с одной арностью.

Каждый enumerable элемент передаётся в качестве аргумента заданной функции fun и обрабатывается своей собственной задачей. Задачи будут связаны с вызывающим процессом, аналогично async/1.

Пример

Асинхронно подсчитайте кодовые точки в каждой строке, затем сложите подсчеты с помощью reduce.

iex> strings = ["long string", "longer string", "there are many of these"]
iex> stream = Task.async_stream(strings, fn text -> text |> String.codepoints() |> Enum.count() end)
iex> Enum.reduce(stream, 0, fn {:ok, num}, acc -> num + acc end)
47

См. async_stream/5 для обсуждения, опций и дополнительных примеров.

@spec async_stream(Enumerable.t(), module(), atom(), [term()], [async_stream_option()]) ::
  Enumerable.t()

Возвращает поток, где заданная функция (module и function_name) применяется асинхронно к каждому элементу в enumerable.

Каждый элемент из enumerable будет добавлен в начало заданного args и обработан своей задачей. Эти задачи будут связаны с промежуточным процессом, который, в свою очередь, будет связан с вызывающим процессом. Это означает, что ошибка в задаче завершит вызывающий процесс, а ошибка в вызывающем процессе завершит все задачи.

При потоковой передаче каждая задача будет генерировать {:ok, value} при успешном завершении или {:exit, reason} если вызывающий процесс ловит исключения. Возможна обработка исключений {:exit, {element, reason}} с помощью опции :zip_input_on_exit. Порядок результатов зависит от значения опции :ordered.

Уровень параллельности и время выполнения задач можно контролировать с помощью опций (см. раздел "Опции" ниже).

Рассмотрите использование Task.Supervisor.async_stream/6 для запуска задач под управлением диспетчера. Если вы обнаружили необходимость ловить исключения, чтобы ошибки в задачах не приводили к завершению вызывающего процесса, рассмотрите использование Task.Supervisor.async_stream_nolink/6 для запуска задач, которые не связаны с вызывающим процессом.

Опции

• :max_concurrency - устанавливает максимальное количество задач, которые могут выполняться одновременно. По умолчанию установлено значение System.schedulers_online/0.

• :ordered - определяет, должны ли результаты возвращаться в том же порядке, что и входной поток. Когда выходной поток упорядочен, Elixir может буферизовать результаты, чтобы выводить их в исходном порядке. Установка этого параметра в false отключает необходимость буферизации за счет удаления упорядоченности. Это также полезно, когда вам нужны только побочные эффекты задач. Обратите внимание, что независимо от значения :ordered, задачи будут обрабатываться асинхронно. Если вам необходимо обрабатывать элементы в порядке, используйте Enum.map/2 или Enum.each/2 вместо этого. По умолчанию установлено значение true.

• :timeout - максимальное время (в миллисекундах или :infinity), которое каждая задача может тратить на выполнение. По умолчанию установлено значение 5000.

• :on_timeout - действия при истечении времени ожидания задачи. Возможные значения:

  • :exit (по умолчанию) - вызывающий процесс (процесс, запустивший задачи) завершается.
  • :kill_task - задача, которая превысила лимит времени, уничтожается. Возвращаемое значение для этой задачи - {:exit, :timeout}.

• :zip_input_on_exit - (с версии 1.14.0) добавляет исходный ввод в :exit кортежи. Возвращаемое значение для этой задачи - {:exit, {input, reason}}, где input - элемент коллекции, вызвавший завершение обработки. По умолчанию установлено значение false.

Пример

Давайте создадим поток, а затем перечислим его:

stream = Task.async_stream(collection, Mod, :expensive_fun, [])
Enum.to_list(stream)

Параллельность может быть увеличена или уменьшена с помощью опции :max_concurrency. Например, если задачи связаны с вводом-выводом, значение может быть увеличено:

max_concurrency = System.schedulers_online() * 2
stream = Task.async_stream(collection, Mod, :expensive_fun, [], max_concurrency: max_concurrency)
Enum.to_list(stream)

Если вас не интересуют результаты вычислений, вы можете запустить поток с помощью Stream.run/1. Также установите ordered: false, так как вы также не заинтересованы в порядке результатов:

stream = Task.async_stream(collection, Mod, :expensive_fun, [], ordered: false)
Stream.run(stream)

Первые асинхронные задачи, завершившие работу

Также можно использовать async_stream/3 для выполнения M задач и поиска N задач, завершивших работу. Например:

[
  &heavy_call_1/0,
  &heavy_call_2/0,
  &heavy_call_3/0
]
|> Task.async_stream(fn fun -> fun.() end, ordered: false, max_concurrency: 3)
|> Stream.filter(&match?({:ok, _}, &1))
|> Enum.take(2)

В примере выше мы выполняем три задачи и ждём завершения первых 2. Мы используем Stream.filter/2, чтобы ограничиться только успешно завершившимися задачами, и затем используем Enum.take/2 для получения N элементов. Важно установить оба ordered: false и max_concurrency: M, где M - количество задач, чтобы обеспечить одновременное выполнение всех вызовов.

Внимание: не связанные асинхронные + take

Если вы хотите потенциально обработать большое количество элементов и сохранить только часть результатов, вы можете обработать больше элементов, чем нужно. Посмотрим на пример:

1..100
|> Task.async_stream(fn i ->
  Process.sleep(100)
  IO.puts(to_string(i))
end)
|> Enum.take(10)

Запуск приведённого выше примера на машине с 8 ядрами обработает 16 элементов, хотя вам нужны только 10, так как async_stream/3 обрабатывает элементы параллельно. Это происходит потому, что он обрабатывает 8 элементов одновременно. Затем все 8 элементов завершаются примерно в одно и то же время, что приводит к запуску обработки ещё 8 элементов. Из этих дополнительных 8 элементов будут использованы только 2, а остальные будут завершены.

В зависимости от задачи, вы можете отфильтровать или ограничить количество элементов заранее:

1..100
|> Stream.take(10)
|> Task.async_stream(fn i ->
  Process.sleep(100)
  IO.puts(to_string(i))
end)
|> Enum.to_list()

В других случаях вы, вероятно, захотите настроить :max_concurrency для ограничения количества переобработанных элементов за счёт уменьшения параллельности. Вы также можете установить количество элементов для взятия, кратное :max_concurrency. Например, установив max_concurrency: 5 в примере выше.

@spec await(t(), timeout()) :: term()

Ожидает ответа от задачи и возвращает его.

В случае смерти процесса задачи, вызывающий процесс завершится с тем же кодом, что и задача.

Можно указать таймаут (в миллисекундах или :infinity) с значением по умолчанию 5000. Если таймаут истечёт, вызывающий процесс завершится. Если процесс задачи связан с вызывающим процессом (что происходит, когда задача запущена с async), то процесс задачи также завершится. Если процесс задачи ловит исключения или не связан с вызывающим процессом, то он продолжит работу.

Эта функция предполагает, что монитор задачи всё ещё активен или сообщение :DOWN монитора находится в очереди сообщений. Если он был отслежен, или сообщение уже получено, эта функция будет ждать в течение таймаута, ожидая сообщение.

Эта функция может быть вызвана только один раз для любой данной задачи. Если вам нужно проверять несколько раз, завершила ли долго выполняющаяся задача вычисления, используйте yield/2 вместо этого.

Примеры

iex> task = Task.async(fn -> 1 + 1 end)
iex> Task.await(task)
2

Совместимость с поведением OTP

Не рекомендуется await долго выполняющуюся задачу внутри поведения OTP, такого как GenServer. Вместо этого вы должны обрабатывать сообщение, пришедшее от задачи, внутри вашего GenServer.handle_info/2 обработчика.

GenServer получит два сообщения при handle_info/2:

• {ref, result} - сообщение с ответом, где ref — ссылка на монитор, возвращённую функцией task.ref, а result — результат задачи

• {:DOWN, ref, :process, pid, reason} - так как все задачи также отслеживаются, вы также получите сообщение :DOWN, доставленное функцией Process.monitor/1. Если вы получите сообщение :DOWN без ответа, это означает, что задача завершилась с ошибкой

Ещё одна вещь, которую нужно иметь в виду, заключается в том, что задачи, запущенные с помощью Task.async/1, всегда связаны со своими вызывающими процессами, и вы, возможно, не захотите, чтобы GenServer завершался, если задача завершится с ошибкой. Поэтому лучше использовать Task.Supervisor.async_nolink/3 внутри поведения OTP. Для полноты картины вот пример GenServer, который запускает задачи и обрабатывает их результаты:

defmodule GenServerTaskExample do
  use GenServer

  def start_link(opts) do
    GenServer.start_link(__MODULE__, :ok, opts)
  end

  def init(_opts) do
    # We will keep all running tasks in a map
    {:ok, %{tasks: %{}}}
  end

  # Imagine we invoke a task from the GenServer to access a URL...
  def handle_call(:some_message, _from, state) do
    url = ...
    task = Task.Supervisor.async_nolink(MyApp.TaskSupervisor, fn -> fetch_url(url) end)

    # After we start the task, we store its reference and the url it is fetching
    state = put_in(state.tasks[task.ref], url)

    {:reply, :ok, state}
  end

  # If the task succeeds...
  def handle_info({ref, result}, state) do
    # The task succeed so we can demonitor its reference
    Process.demonitor(ref, [:flush])

    {url, state} = pop_in(state.tasks[ref])
    IO.puts "Got #{inspect(result)} for URL #{inspect url}"
    {:noreply, state}
  end

  # If the task fails...
  def handle_info({:DOWN, ref, _, _, reason}, state) do
    {url, state} = pop_in(state.tasks[ref])
    IO.puts "URL #{inspect url} failed with reason #{inspect(reason)}"
    {:noreply, state}
  end
end

После определения сервера вам нужно запустить диспетчер задач выше и GenServer в вашей дереве управления:

children = [
  {Task.Supervisor, name: MyApp.TaskSupervisor},
  {GenServerTaskExample, name: MyApp.GenServerTaskExample}
]

Supervisor.start_link(children, strategy: :one_for_one)

@spec await_many([t()], timeout()) :: [term()]

Ожидает ответы от нескольких задач и возвращает их.

Эта функция получает список задач и ожидает их ответы в течение заданного интервала времени. Она возвращает список результатов в том же порядке, что и задачи, переданные в аргументе tasks.

Если какой-либо из процессов задачи завершится с ошибкой, вызывающий процесс завершится с тем же кодом, что и эта задача.

Можно указать таймаут (в миллисекундах или :infinity) с значением по умолчанию 5000. Если таймаут истечёт, вызывающий процесс завершится. Любые процессы задач, связанные с вызывающим процессом (что происходит, когда задача запущена с async), также завершатся. Процессы задач, ловящие исключения или не связанные с вызывающим процессом, будут продолжать выполняться.

Эта функция предполагает, что мониторы задач всё ещё активны или сообщение :DOWN монитора находится в очереди сообщений. Если какие-либо задачи были отслежены, или сообщение уже получено, эта функция будет ждать в течение таймаута.

Эта функция может быть вызвана только один раз для любой данной задачи. Если вам нужно проверять несколько раз, завершила ли долго выполняющаяся задача вычисления, используйте yield_many/2 вместо этого.

Совместимость с поведением OTP

Не рекомендуется await запускать долго выполняющиеся задачи внутри поведения OTP, такого как GenServer. Смотрите await/2 для получения дополнительной информации.

Примеры

iex> tasks = [
...>   Task.async(fn -> 1 + 1 end),
...>   Task.async(fn -> 2 + 3 end)
...> ]
iex> Task.await_many(tasks)
[2, 5]

@spec child_spec(term()) :: Supervisor.child_spec()

Возвращает спецификацию для запуска задачи под надзором.

arg передаётся в качестве аргумента функции Task.start_link/1 в поле :start спецификации.

Для получения дополнительной информации см. модуль Supervisor, функцию Supervisor.child_spec/2 и тип Supervisor.child_spec/0.

@spec completed(any()) :: t()

Запускает задачу, которая сразу же завершается с указанным result.

В отличие от async/1, эта задача не порождает связанный процесс. Её можно дождаться или использовать для передачи управления, как и любую другую задачу.

Использование

В некоторых случаях полезно создать задачу «completed», которая представляет задачу, уже выполненную и породившую результат. Например, при обработке данных вы можете определить, что некоторые входные данные некорректны до их отправки для дальнейшей обработки:

def process(data) do
  tasks =
    for entry <- data do
      if invalid_input?(entry) do
        Task.completed({:error, :invalid_input})
      else
        Task.async(fn -> further_process(entry) end)
      end
    end

  Task.await_many(tasks)
end

Во многих случаях Task.completed/1 можно избежать, возвращая результат напрямую. Вам, как правило, потребуется только этот вариант при работе со смешанной асинхронностью, когда группа входных данных будет обрабатываться частично синхронно, а частично асинхронно.

@spec ignore(t()) :: {:ok, term()} | {:exit, term()} | nil

Игнорирует существующую задачу.

Это означает, что задача будет продолжать выполняться, но она будет отсоединена, и вы больше не сможете передавать ей управление, ждать её или завершать её.

Возвращает {:ok, reply} если ответ получен до игнорирования задачи, {:exit, reason} если задача завершилась до игнорирования, в противном случае nil.

Важно: избегайте использования Task.async/1,3 и последующего немедленного игнорирования задачи. Если вы хотите запустить задачи, результаты которых вас не интересуют, используйте Task.Supervisor.start_child/2 вместо этого.

@spec shutdown(t(), timeout() | :brutal_kill) :: {:ok, term()} | {:exit, term()} | nil

Отсоединяет и завершает задачу, а затем проверяет получение ответа.

Возвращает {:ok, reply} если ответ получен во время завершения задачи, {:exit, reason} если задача завершилась с ошибкой, в противном случае nil . После завершения вы больше не можете ждать или передавать управление этой задаче.

Второй аргумент — это либо таймаут, либо :brutal_kill. В случае таймаута задаче-процессу отправляется сигнал завершения :shutdown, и если она не завершится в течение таймаута, она убивается. При использовании :brutal_kill задача убивается сразу. В случае аномального завершения задачи (возможно, убитой другим процессом) эта функция завершится по той же причине.

Вызов этой функции не требуется при завершении вызывающего процесса, если не происходит выход с причиной :normal или если задача обрабатывает завершения. Если вызывающий процесс завершается по причине, отличной от :normal, и задача не обрабатывает завершения, сигнал завершения вызывающего процесса остановит задачу. Вызывающий процесс может завершиться с причиной :shutdown для завершения всех связанных процессов, включая задачи, которые не обрабатывают завершения, без генерации каких-либо сообщений об ошибках.

Если задача не связана с процессом, например, задачи, запущенные с помощью Task.completed/1, мы проверяем ответ или ошибку соответственно, но без завершения процесса.

Если монитор задачи уже отслеживается или получил сообщение, а в очереди сообщений нет ответа, эта функция вернёт {:exit, :noproc} в качестве результата или причина завершения не может быть определена.

@spec start((-> any())) :: {:ok, pid()}

Запускает задачу.

fun должен быть анонимной функцией без аргументов.

Это следует использовать только тогда, когда задача используется для побочных эффектов (например, ввода-вывода), и вас не интересуют её результаты или успешное выполнение.

Если текущий узел закрывается, узел завершится, даже если задача не была завершена. По этой причине рекомендуется использовать Task.Supervisor.start_child/2 вместо этого, что позволяет контролировать время завершения с помощью параметра :shutdown.

@spec start(module(), atom(), [term()]) :: {:ok, pid()}

Запускает задачу.

Это следует использовать только тогда, когда задача используется для побочных эффектов (например, ввода-вывода), и вас не интересуют её результаты или успешное выполнение.

Если текущий узел закрывается, узел завершится, даже если задача не была завершена. По этой причине рекомендуется использовать Task.Supervisor.start_child/2 вместо этого, что позволяет контролировать время завершения с помощью параметра :shutdown.

@spec start_link((-> any())) :: {:ok, pid()}

Запускает задачу как часть дерева надзора с заданным fun.

fun должен быть анонимной функцией без аргументов.

Используется для запуска статически контролируемой задачи в рамках дерева надзора.

@spec start_link(module(), atom(), [term()]) :: {:ok, pid()}

Запускает задачу как часть дерева надзора с заданным module, function, и args.

Используется для запуска статически контролируемой задачи в рамках дерева надзора.

@spec yield(t(), timeout()) :: {:ok, term()} | {:exit, term()} | nil

Временный блок вызывающего процесса в ожидании ответа задачи.

Возвращает {:ok, reply} если ответ получен, nil если ответ не получен или {:exit, reason} если задача уже завершилась. Имейте в виду, что, как правило, ошибка задачи также приводит к завершению процесса, владеющего задачей. Поэтому эта функция может вернуть {:exit, reason} если выполняется хотя бы одно из следующих условий:

• процесс задачи завершился с причиной :normal
• процесс задачи не связан с вызывающим (задача запущена с помощью Task.Supervisor.async_nolink/2 или Task.Supervisor.async_nolink/4)
• вызывающий процесс обрабатывает завершения

Таймаут, в миллисекундах или :infinity, может быть задан со значением по умолчанию 5000. Если время истечёт прежде чем будет получено сообщение от задачи, эта функция вернёт nil и монитор останется активным. Поэтому yield/2 можно вызывать несколько раз для одной и той же задачи.

Эта функция предполагает, что монитор задачи по-прежнему активен или сообщение монитора :DOWN находится в очереди сообщений. Если монитор был отменён или сообщение уже получено, эта функция будет ожидать в течение таймаута, ожидая сообщения.

Если вы хотите остановить задачу, если она не ответила в течение timeout миллисекунд, вы должны объединить её с shutdown/1, как показано ниже:

case Task.yield(task, timeout) || Task.shutdown(task) do
  {:ok, result} ->
    result

  nil ->
    Logger.warning("Failed to get a result in #{timeout}ms")
    nil
end

Если вы хотите проверить задачу, но оставить её работающей после истечения таймаута, вы можете объединить её с ignore/1, как показано ниже:

case Task.yield(task, timeout) || Task.ignore(task) do
  {:ok, result} ->
    result

  nil ->
    Logger.warning("Failed to get a result in #{timeout}ms")
    nil
end

Это гарантирует, что если задача завершится после истечения timeout но до вызова shutdown/1, вы всё равно получите результат, так как shutdown/1 разработан для обработки такого случая и возвращения результата.

@spec yield_many([t()], timeout()) :: [{t(), {:ok, term()} | {:exit, term()} | nil}]

@spec yield_many([t()],
  limit: pos_integer(),
  timeout: timeout(),
  on_timeout: :nothing | :ignore | :kill_task
) :: [{t(), {:ok, term()} | {:exit, term()} | nil}]

Возвращает результаты множественных задач в заданном интервале времени.

Эта функция получает список задач и ожидает их ответы в заданном интервале времени. Она возвращает список пар кортежей из двух элементов, где первой является задача, а второй — возвращённый результат. Задачи в возвращаемом списке будут в том же порядке, что и в аргументе tasks.

Аналогично yield/2, результат каждой задачи будет

• {:ok, term} если задача успешно сообщила свой результат в заданном интервале времени
• {:exit, reason} если задача завершилась аварийно
• nil если задача всё ещё выполняется, либо потому, что достигнут лимит, либо истекло время ожидания

См. yield/2 для получения дополнительной информации.

Пример

Task.yield_many/2 позволяет разработчикам запускать несколько задач и получать результаты, полученные в заданный промежуток времени. Если объединить это с Task.shutdown/2 (или Task.ignore/1), это позволяет собрать эти результаты и отменить (или проигнорировать) задачи, которые не ответили вовремя.

Рассмотрим пример.

tasks =
  for i <- 1..10 do
    Task.async(fn ->
      Process.sleep(i * 1000)
      i
    end)
  end

tasks_with_results = Task.yield_many(tasks, timeout: 5000)

results =
  Enum.map(tasks_with_results, fn {task, res} ->
    # Shut down the tasks that did not reply nor exit
    res || Task.shutdown(task, :brutal_kill)
  end)

# Here we are matching only on {:ok, value} and
# ignoring {:exit, _} (crashed tasks) and `nil` (no replies)
for {:ok, value} <- results do
  IO.inspect(value)
end

В примере выше мы создаём задачи, которые спят от 1 до 10 секунд и возвращают количество проспанных секунд. Если выполнить код сразу, вы увидите числа от 1 до 5, поскольку это задачи, которые ответили в заданное время. Все остальные задачи будут остановлены с помощью вызова Task.shutdown/2.

Для удобства вы можете добиться аналогичного поведения, указав опцию :on_timeout в качестве :kill_task (или :ignore). См. Task.await_many/2, если вам нужно завершить процесс вызывающей программы при истечении времени ожидания.

Опции

Вторым аргументом является либо таймаут, либо опции, которые по умолчанию:

• :limit - максимальное количество задач, ожидаемых для обработки. Если предел достигнут до истечения таймаута, функция возвращает немедленно без срабатывания поведения :on_timeout

• :timeout - максимальное время (в миллисекундах или :infinity) выполнения каждой задачи. По умолчанию 5000.

• :on_timeout - действия при истечении времени ожидания задачи. Возможные значения:

  • :nothing - ничего не делать (по умолчанию). Задачи всё ещё можно ожидать, получать результаты, игнорировать или останавливать позже.
  • :ignore - результаты задачи будут проигнорированы.
  • :kill_task - задача, истекшая по таймауту, будет убита.