最佳化僅動態啟動子項目的監督程式。

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 旗標中給予。