概述

OTP 平臺的容錯性高，是因為它提供了機制來監控所有 processes 的狀態，如果有程序出現異常， 不僅可以及時檢測到錯誤，還可以對 processes 進行重啟等操作。

有了 supervisor，可以有效的提高系統的可用性，一個 supervior 監督一個或多個應用， 同時， supervior 也可以監督 supervior，從而形成一個監督樹，提高整個系統的可用性。

注意 ，supervior 最好只用於監督，不要有其他的業務邏輯處理，越是接近監督樹根部的 supervior 就要越簡單， 因為 supervior 簡單就不容易出錯，它是保證系統高可用的關鍵。

監督者示例

下面，使用 elixir 中提供的 Supervisor 模組，構造簡單的監督示例來演示如何提高系統的可用性。

監督策略

監督策略有4種：

1. :one_for_one 只重啟出錯的 process
2. :one_for_all 當有 process 出錯時，重啟所有的 process
3. :rest_for_one 重啟出錯的 process ，以及所有在它之後啟動的 process（也就是重啟對出錯 process 有依賴的 所有 process）
4. :simple_one_for_one 類似 :one_for_one ，但是 supervior 只能包含一個 process

監督策略的轉換非常簡單，下面演示2種監督策略的示例：

one for one

defmodule PseudoServerA do
  use GenServer

  def start_link(state, opts \\ []) do
    GenServer.start_link(__MODULE__, state, opts)
  end

  def handle_call(:display, _from, []) do
    {:reply, 'ServerA PID: ' ++ :erlang.pid_to_list(self()), []}
  end

  def handle_cast(:err, []) do
    {:stop, "stop ServerA", []}
  end
end

defmodule PseudoServerB do
  use GenServer

  def start_link(state, opts \\ []) do
    GenServer.start_link(__MODULE__, state, opts)
  end

  def handle_call(:display, _from, []) do
    {:reply, 'ServerB PID: ' ++ :erlang.pid_to_list(self()), []}
  end

  def handle_cast(:err, []) do
    {:stop, "stop ServerB", []}
  end
end

defmodule PseudoServerC do
  use GenServer

  def start_link(state, opts \\ []) do
    GenServer.start_link(__MODULE__, state, opts)
  end

  def handle_call(:display, _from, []) do
    {:reply, 'ServerC PID: ' ++ :erlang.pid_to_list(self()), []}
  end

  def handle_cast(:err, []) do
    {:stop, "stop ServerC", []}
  end
end

defmodule SupervisorTest do
  import Supervisor.Spec

  def init() do
    children = [
      worker(PseudoServerA, [[], [name: :server_a]]),
      worker(PseudoServerB, [[], [name: :server_b]]),
      worker(PseudoServerC, [[], [name: :server_c]])
    ]

    # Start the supervisor with children
    Supervisor.start_link(children, strategy: :one_for_one)
  end

end
 

測試方式：

$ iex -S mix

# 啟動 supervisor 及其監督的3個 process 
iex(1)> SupervisorTest.init
{:ok, #PID<0.145.0>}

# 啟動後， 3個 process 的 PID 如下
iex(2)> GenServer.call(:server_a, :display)
'ServerA PID: <0.146.0>'
iex(3)> GenServer.call(:server_b, :display)
'ServerB PID: <0.147.0>'
iex(4)> GenServer.call(:server_c, :display)
'ServerC PID: <0.148.0>'

# 通過訊息 :err 讓 serverA 出錯
iex(5)> GenServer.cast(:server_a, :err)
:ok
iex(6)>
14:47:53.119 [error] GenServer :server_a terminating
** (stop) "stop ServerA"
Last message: {:"$gen_cast", :err}
State: []

nil

# serverA 出錯後，再次檢視3個process的PID，發現 supervisor 只重啟了 serverA，符合策略 :one_for_one
iex(7)> GenServer.call(:server_a, :display)
'ServerA PID: <0.155.0>'
iex(8)> GenServer.call(:server_b, :display)
'ServerB PID: <0.147.0>'
iex(9)> GenServer.call(:server_c, :display)
'ServerC PID: <0.148.0>'
 

one_for_all

我們換一種監督策略試試看，只需要將上面的程式碼

# Start the supervisor with children
Supervisor.start_link(children, strategy: :one_for_one)

改成

# Start the supervisor with children
Supervisor.start_link(children, strategy: :one_for_all)

測試步驟 和 one_for_one 一樣：

$ iex -S mix

# 啟動 supervisor 及其監督的3個 process 
iex(1)> SupervisorTest.init
{:ok, #PID<0.145.0>}

# 啟動後， 3個 process 的 PID 如下
iex(2)> GenServer.call(:server_a, :display)
'ServerA PID: <0.146.0>'
iex(3)> GenServer.call(:server_b, :display)
'ServerB PID: <0.147.0>'
iex(4)> GenServer.call(:server_c, :display)
'ServerC PID: <0.148.0>'

# 通過訊息 :err 讓 serverA 出錯
iex(5)> GenServer.cast(:server_a, :err)
:ok
iex(6)>
14:55:16.183 [error] GenServer :server_a terminating
 ** (stop) "stop ServerA"
 Last message: {:"$gen_cast", :err}
 State: []

 nil

# serverA 出錯後，再次檢視3個process的PID，發現 supervisor 重啟了所有 process，符合策略 :one_for_all
iex(7)> GenServer.call(:server_a, :display)
'ServerA PID: <0.153.0>'
iex(8)> GenServer.call(:server_b, :display)
'ServerB PID: <0.154.0>'
iex(9)> GenServer.call(:server_c, :display)
'ServerC PID: <0.156.0>'

監督樹

監督者並不是一維的，監督者也可以監督其它監督者，從而形成樹狀的監督關係。

修改上面的測試程式碼如下：（只修改了 Supervisor 的部分）

defmodule PseudoServerA do
  use GenServer

  def start_link(state, opts \\ []) do
    GenServer.start_link(__MODULE__, state, opts)
  end

  def handle_call(:display, _from, []) do
    {:reply, 'ServerA PID: ' ++ :erlang.pid_to_list(self()), []}
  end

  def handle_cast(:err, []) do
    {:stop, "stop ServerA", []}
  end
end

defmodule PseudoServerB do
  use GenServer

  def start_link(state, opts \\ []) do
    GenServer.start_link(__MODULE__, state, opts)
  end

  def handle_call(:display, _from, []) do
    {:reply, 'ServerB PID: ' ++ :erlang.pid_to_list(self()), []}
  end

  def handle_cast(:err, []) do
    {:stop, "stop ServerB", []}
  end
end

defmodule PseudoServerC do
  use GenServer

  def start_link(state, opts \\ []) do
    GenServer.start_link(__MODULE__, state, opts)
  end

  def handle_call(:display, _from, []) do
    {:reply, 'ServerC PID: ' ++ :erlang.pid_to_list(self()), []}
  end

  def handle_cast(:err, []) do
    {:stop, "stop ServerC", []}
  end
end

defmodule SupervisorBranch do
  import Supervisor.Spec

  def start_link(state) do
    children = [
      worker(PseudoServerA, [[], [name: :server_a]]),
      worker(PseudoServerB, [[], [name: :server_b]]),
    ]

    Supervisor.start_link(children, strategy: :one_for_one)
  end

end

defmodule SupervisorRoot do
  import Supervisor.Spec

  def init() do
    children = [
      supervisor(SupervisorBranch, [[name: :supervisor_branch]]),
      worker(PseudoServerC, [[], [name: :server_c]])
    ]

    # Start the supervisor with children
    Supervisor.start_link(children, strategy: :one_for_all)
  end

end

測試流程如下：

# 啟動 根 監督者 
iex(1)> SupervisorRoot.init
{:ok, #PID<0.149.0>}

# 啟動後，檢視 3 個process 的PID
iex(2)> GenServer.call(:server_a, :display)
'ServerA PID: <0.151.0>'
iex(3)> GenServer.call(:server_b, :display)
'ServerB PID: <0.152.0>'
iex(4)> GenServer.call(:server_c, :display)
'ServerC PID: <0.153.0>'

# 通過訊息 :err 讓 serverA 出錯
iex(5)> GenServer.cast(:server_a, :err)
:ok
iex(6)>
15:31:15.846 [error] GenServer :server_a terminating
 ** (stop) "stop ServerA"
 Last message: {:"$gen_cast", :err}
 State: []

 nil

 # serverA 出錯後，因為它的監督者 SupervisorBranch 的策略是 :one_for_one，所以只重啟了 serverA
 iex(7)> GenServer.call(:server_a, :display)
 'ServerA PID: <0.158.0>'
 iex(8)> GenServer.call(:server_b, :display)
 'ServerB PID: <0.152.0>'
 iex(9)> GenServer.call(:server_c, :display)
 'ServerC PID: <0.153.0>'

 # 通過訊息 :err 讓 serverC 出錯
 iex(10)> GenServer.cast(:server_c, :err)
 :ok

 15:31:35.264 [error] GenServer :server_c terminating
 ** (stop) "stop ServerC"
 Last message: {:"$gen_cast", :err}
 State: []

 # serverC 出錯後，因為它的監督者 SupervisorRoot 的策略是 :one_for_all，所以所有的 proocess 都重啟了
 iex(11)> GenServer.call(:server_a, :display)
 'ServerA PID: <0.166.0>'
 iex(12)> GenServer.call(:server_c, :display)
 'ServerC PID: <0.168.0>'
 iex(13)> GenServer.call(:server_b, :display)
 'ServerB PID: <0.167.0>'

通過監督樹，我們可以給不同的 process 分組，然後讓每個組有不同的監督策略。

總結

有了監督機制，可以及時的把握所有 process 的狀態，通過監督樹，還可以加入不同恢復機制。 因此，用好 Supervisor 模組，可以極大提高系統的可用性。