概述

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)