一个优化的主管，只在动态情况下启动子进程。

该 Supervisor 模块旨在处理主要是在主管启动时按指定顺序启动的静态子进程。一个 DynamicSupervisor 启动时没有子进程。相反，子进程是通过 start_child/2 按需启动的，子进程之间没有顺序。这使 DynamicSupervisor 能够通过使用高效的数据结构来容纳数百万个子进程，并能够并发执行某些操作，例如关闭。

示例

动态主管启动时没有子进程，通常有一个名称

children = [
  {DynamicSupervisor, name: MyApp.DynamicSupervisor, strategy: :one_for_one}
]

Supervisor.start_link(children, strategy: :one_for_one)

在子进程规范中给出的选项在 start_link/1 中有说明。

一旦动态主管运行，我们就可以使用它按需启动子进程。给定此示例 GenServer

defmodule Counter do
  use GenServer

  def start_link(initial) do
    GenServer.start_link(__MODULE__, initial)
  end

  def inc(pid) do
    GenServer.call(pid, :inc)
  end

  def init(initial) do
    {:ok, initial}
  end

  def handle_call(:inc, _, count) do
    {:reply, count, count + 1}
  end
end

我们可以使用 start_child/2 和子进程规范来启动一个 Counter 服务器

{:ok, counter1} = DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 0})
Counter.inc(counter1)
#=> 0

{:ok, counter2} = DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 10})
Counter.inc(counter2)
#=> 10

DynamicSupervisor.count_children(MyApp.DynamicSupervisor)
#=> %{active: 2, specs: 2, supervisors: 0, workers: 2}

可扩展性和分区

该 DynamicSupervisor 是一个负责启动其他进程的单一进程。在某些应用程序中，DynamicSupervisor 可能会成为瓶颈。为了解决这个问题，您可以启动多个 DynamicSupervisor 实例，然后选择一个“随机”实例来启动子进程。

而不是

children = [
  {DynamicSupervisor, name: MyApp.DynamicSupervisor}
]

和

DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 0})

您可以这样做

children = [
  {PartitionSupervisor,
   child_spec: DynamicSupervisor,
   name: MyApp.DynamicSupervisors}
]

然后

DynamicSupervisor.start_child(
  {:via, PartitionSupervisor, {MyApp.DynamicSupervisors, self()}},
  {Counter, 0}
)

在上面的代码中，我们启动了一个分区主管，它默认会为机器中的每个内核启动一个动态主管。然后，您不是按名称调用 DynamicSupervisor，而是通过分区主管调用它，使用 self() 作为路由键。这意味着每个进程都将分配到一个现有的动态主管。阅读 PartitionSupervisor 文档以了解更多信息。

基于模块的主管

与 Supervisor 相似，动态主管也支持基于模块的主管。

defmodule MyApp.DynamicSupervisor do
  # Automatically defines child_spec/1
  use DynamicSupervisor

  def start_link(init_arg) do
    DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
  end

  @impl true
  def init(_init_arg) do
    DynamicSupervisor.init(strategy: :one_for_one)
  end
end

请参阅 Supervisor 文档，了解何时可能需要使用基于模块的主管。在 use DynamicSupervisor 之前立即添加的 @doc 注释将附加到生成的 child_spec/1 函数。

use DynamicSupervisor

当您 use DynamicSupervisor 时，DynamicSupervisor 模块将设置 @behaviour DynamicSupervisor 并定义一个 child_spec/1 函数，因此您的模块可以用作监督树中的子进程。

名称注册

主管受限于与 GenServer 相同的名称注册规则。在 GenServer 文档中详细了解这些规则。

从 Supervisor 的 :simple_one_for_one 迁移

如果您之前使用过 Supervisor 模块中已弃用的 :simple_one_for_one 策略，您可以通过几个步骤迁移到 DynamicSupervisor。

想象一下给定的“旧”代码

defmodule MySupervisor do
  use Supervisor

  def start_link(init_arg) do
    Supervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
  end

  def start_child(foo, bar, baz) do
    # This will start child by calling MyWorker.start_link(init_arg, foo, bar, baz)
    Supervisor.start_child(__MODULE__, [foo, bar, baz])
  end

  @impl true
  def init(init_arg) do
    children = [
      # Or the deprecated: worker(MyWorker, [init_arg])
      %{id: MyWorker, start: {MyWorker, :start_link, [init_arg]}}
    ]

    Supervisor.init(children, strategy: :simple_one_for_one)
  end
end

它可以像这样升级到 DynamicSupervisor

defmodule MySupervisor do
  use DynamicSupervisor

  def start_link(init_arg) do
    DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
  end

  def start_child(foo, bar, baz) do
    # If MyWorker is not using the new child specs, we need to pass a map:
    # spec = %{id: MyWorker, start: {MyWorker, :start_link, [foo, bar, baz]}}
    spec = {MyWorker, foo: foo, bar: bar, baz: baz}
    DynamicSupervisor.start_child(__MODULE__, spec)
  end

  @impl true
  def init(init_arg) do
    DynamicSupervisor.init(
      strategy: :one_for_one,
      extra_arguments: [init_arg]
    )
  end
end

区别在于 DynamicSupervisor 在调用 start_child/2 时期望子进程规范，而不是在 init 回调中。如果有任何初始化时给出的初始参数，例如 [initial_arg]，可以在 DynamicSupervisor.init/1 上的 :extra_arguments 标志中给出。