如何在 Elixir 中等待多个任务？

Question

我想同时执行多项任务。在 Javascript 中，我会这样做：

async function cook_an_egg() {}

async function take_shower() {}

async function call_mum() {}

await Promise.all([cook_an_egg(), take_shower(), call_mum()])

如何在 Elixir 任务模块中实现Promise.all？ 从documentation，看来你只能await 1 个任务；在每个 task 中定义 1 个函数；并仅将相同的功能应用于具有 async_stream 的多个项目。

Answer 1

对于 Elixir v1.11.0 及更高版本

Task.await_many 正是为此而设计的。它正确地处理了整个超时，并且在面对退出、超时等时应该做最不令人惊讶的事情。

tasks = [
  Task.async(fn -> cook_an_egg(:medium) end),
  Task.async(fn -> take_shower(10) end),
  Task.async(fn -> call_mum() end),
]

Task.await_many(tasks)

对于旧版本

比Task.await 更防弹的解决方案是Task.yield_many。不幸的是，它有点冗长，因为它让我们自己负责处理超时和死任务。如果我们想模仿async/await的行为并在出现问题时退出，它会是这样的：

tasks = [
  Task.async(fn -> cook_an_egg(:medium) end),
  Task.async(fn -> take_shower(10) end),
  Task.async(fn -> call_mum() end),
]

Task.yield_many(tasks)
|> Enum.map(fn {task, result} ->
  case result do
    nil ->
      Task.shutdown(task, :brutal_kill)
      exit(:timeout)
    {:exit, reason} ->
      exit(reason)
    {:ok, result} ->
      result
  end
end)

为什么不使用await？

使用Task.await 可以在简单的情况下工作，但如果您关心超时，您可能会遇到麻烦。跨列表的映射是按顺序进行的，这意味着每个 Task.await 在给出结果之前将阻塞到指定的超时时间，此时我们移动到列表中的下一项并阻塞 再次 for up到完全超时。

我们可以通过创建一个休眠 1-8 秒的任务列表来演示这种行为。默认超时时间为 5 秒，其中一些任务在直接使用 await 调用时会被终止，但是当我们遍历列表时，情况并非如此：

for ms <- [2_000, 4_000, 6_000] do
  Task.async(fn -> Process.sleep(ms); ms end)
end
|> Enum.map(&Task.await/1)

# Blocks for 6 seconds
# => [2000, 4000, 6000]

# Each `await` picks up after the previous one finishes with a fresh 5s timeout.
# Since each one blocks for 2s before finishing, no timeout is triggered
# but the total run time runs over.
 
# async(2s)--await(2s)-->(2s)
# async(4s)                  --await(2s)-->(4s)
# async(6s)                                    --await(2s)-->(6s)

如果我们修改它以使用Task.yield_many，我们可以获得所需的行为：

for ms <- [2_000, 4_000, 6_000] do
  Task.async(fn -> Process.sleep(ms); ms end)
end
|> Task.yield_many(5000)
|> Enum.map(fn {t, res} -> res || Task.shutdown(t, :brutal_kill) end)

# Blocks for 5 seconds
# => [{:ok, 2000}, {:ok, 4000}, nil]

Answer 2

自从提出这个问题后，Elixir 的任务模块就萌生了新的力量。

Task.await_many/2 和 Task.yield_many/2 都有，听起来像。

回答原问题中的例子：

cook_an_egg = Task.async(fn -> end)
take_shower = Task.async(fn -> end)
call_mum = Task.async(fn -> end)
Task.await_many([cook_an_egg, take_shower, call_mum])

---

没有与Promise.any 类似的东西，但您可以使用Task.yield_many/2 轻松编写一个

Answer 3

您可以将await 函数映射到任务引用列表。 类似的东西

tasks = Enum.reduce(0..9, [], fn _, acc -> 
  [Task.async(&any_job/0) | acc]
end)

Enum.map(tasks, &Task.await/1)