Elixir OTP 监督树与任务并发：Supervisor、GenServer 与 Task

# OTP 不是库，是「构建容错系统的框架」
# 核心设计：监督树（Supervision Tree）
#   叶子节点：Worker（GenServer/Agent/Task）做实际工作
#   中间节点：Supervisor 监督子进程，崩溃时按策略重启
#   根节点：Application 管理整个 supervision tree
# 目标：局部故障不扩散，自动恢复不人工

Application.start → Supervisor.init → 启动子进程（GenServer/Task/其他 Supervisor）
→ 子进程注册名字 → 系统进入运行状态
# 全部失败则 Application 启动失败 → 无半启动状态

defmodule Counter do
  use GenServer

  # 客户端 API
  def start_link(init_val), do: GenServer.start_link(__MODULE__, init_val, name: __MODULE__)
  def increment, do: GenServer.cast(__MODULE__, :increment)
  def get, do: GenServer.call(__MODULE__, :get)

  # 服务端回调
  def init(init_val), do: {:ok, init_val}

  def handle_cast(:increment, state) do
    {:noreply, state + 1}
  end

  def handle_call(:get, _from, state) do
    {:reply, state, state}
  end
end

call：同步 → 等回复 → 用 handle_call（需 from 参数，{:reply, reply, state}）
cast：异步 → 发完即走 → 用 handle_cast（{:noreply, state}）
info：其他进程发的裸消息、定时器超时、监控 DOWN 信号 → handle_info

:one_for_one      — 一个子进程崩溃，只重启它
:one_for_all      — 一个子进程崩溃，重启全部子进程
:rest_for_one     — 一个子进程崩溃，重启它和它后面的所有子进程
:simple_one_for_one — 动态添加同类型子进程（ Worker 池）

defmodule MyApp.Supervisor do
  use Supervisor

  def init(_args) do
    children = [
      {Counter, 0},
      {MyApp.Repo, []},
      {Task.Supervisor, name: MyApp.TaskSupervisor}
    ]

    Supervisor.init(children,
      strategy: :one_for_one,
      max_restarts: 5,      # 5 次重启
      max_seconds: 10       # 10 秒内
    )
  end
end

transient：只在异常退出时重启（正常 exit 不重启）
temporary：永不重启
permanent：总是重启（默认）

# 生命周期：
# init 失败 → Supervisor 标记子进程失败 → 根据策略重启
# 超过 MaxR/MaxT → Supervisor 自己也崩溃，向上传播

# 启动异步任务
task = Task.async(fn -> HTTPoison.get!("https://api.example.com") end)

# 等待结果
result = Task.await(task, 5000)  # 5 秒超时

# 多个并发
tasks = [
  Task.async(fn -> fetch_user(1) end),
  Task.async(fn -> fetch_user(2) end),
  Task.async(fn -> fetch_user(3) end)
]
results = Task.yield_many(tasks, 5000)

# Task.Supervisor 下启动 → 崩溃被 Supervisor 处理
task = Task.Supervisor.async(MyApp.TaskSupervisor, fn ->
  risky_operation()
end)

Task.await(task)

# Task.Supervisor.start_child 不链接（fire-and-forget）
Task.Supervisor.start_child(MyApp.TaskSupervisor, fn ->
  send_notification()
end)

# 超时处理
result = Task.yield(task, 1000) || Task.shutdown(task)

# Task.yield 返回 nil=任务仍在跑，{:ok, val}=完成
# Task.shutdown 发退出信号终止任务

# 只需要存一个值 + 读/写操作
# 不需要复杂消息处理 → 比 GenServer 轻量
# 例：配置缓存、计数器、简单状态机

{:ok, pid} = Agent.start_link(fn -> %{} end, name: :config)

# 获取
Agent.get(:config, &Map.get(&1, :key))

# 更新
Agent.update(:config, &Map.put(&1, :key, "value"))

# 获取并更新（原子操作）
Agent.get_and_update(:config, fn state ->
  {state[:key], Map.put(state, :key, "new")}
end)

# Supervisor 的 children 在 init 时固定
# DynamicSupervisor：运行时动态添加/删除子进程
# 用例：WebSocket 连接池、长轮询客户端、临时 Worker

defmodule MyApp.DynamicSupervisor do
  use DynamicSupervisor

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

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

  def start_child(spec) do
    DynamicSupervisor.start_child(__MODULE__, spec)
  end
end

# 使用
MyApp.DynamicSupervisor.start_child(
  {MyWorker, arg}
)

# 启动
Registry.start_link(keys: :unique, name: MyApp.Registry)

# 注册进程
Registry.register(MyApp.Registry, "user_123", %{})

# 查找进程
Registry.lookup(MyApp.Registry, "user_123")
# => [{pid, value}]

# 通过 Registry 发送消息
[{pid, _}] = Registry.lookup(MyApp.Registry, "user_123")
send(pid, :ping)

# :duplicate 允许一个 key 对应多个进程
# 用例：Pub/Sub 订阅者列表、房间在线用户
Registry.lookup(MyApp.PubSub, "room:general")
# => [{pid1, sub1}, {pid2, sub2}, ...]

my_app/
├── lib/
│   ├── my_app.ex           # Application 回调模块
│   ├── my_app/
│   │   ├── supervisor.ex   # 顶级 Supervisor
│   │   ├── worker.ex       # GenServer Worker
│   │   └── ...
├── mix.exs                 # 项目配置 + application 规格

defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      MyApp.Repo,
      MyAppWeb.Endpoint,
      {Phoenix.PubSub, name: MyApp.PubSub}
    ]
    Supervisor.start_link(children, strategy: :one_for_one, name: MyApp.Supervisor)
  end
end

# mix.exs
  def application do
    [
      mod: {MyApp.Application, []},
      extra_applications: [:logger, :runtime_tools]
    ]
  end

# 启动带名字的节点
iex --sname node1@localhost

# 在 iex 中连接
Node.connect(:node2@localhost)   # => true/false
Node.list()                       # => [:node2@localhost]

# 在 node1 上调用 node2 的模块
GenServer.call({Counter, :node2@localhost}, :get)

# 跨节点 spawn
Node.spawn(:node2@localhost, fn -> IO.puts("Hello from node2") end)

# 安全：默认 cookie 认证，生产环境用 TLS（-proto_dist inet_tls）
# 网络分区：脑裂时用 net_kernel 监测，设计分区容忍
# 不适用于：跨地域高延迟（用 GenStage/CQRS 替代）