Elixir：Supervisor下Worker获取Controller进程PID的实现问题

我来帮你搞定用Supervisor管理Worker和Controller进程、让Worker顺利拿到Controller PID的问题～下面给你几个可行的解决方案，都是Elixir生态里常用的实践：

这个方案最直接，先让Supervisor启动Controller，再启动Worker，同时给Controller注册一个全局名称，Worker初始化时直接通过名称获取PID。

defmodule XYZ.MySup do
  use Supervisor

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

  @impl true
  def init(_opts) do
    # 先启动Controller，再启动Worker，保证Controller先就绪
    children = [
      {XYZ.Controller, []},
      {XYZ.Worker, []},
      {XYZ.Worker, []} # 可以添加任意数量Worker
    ]

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

defmodule XYZ.Controller do
  use GenServer

  def start_link(opts) do
    # 注册全局进程名，方便Worker查找
    GenServer.start_link(__MODULE__, opts, name: XYZ.Controller)
  end

  @impl true
  def init(_opts) do
    {:ok, %{}}
  end

  # 处理Worker的汇报消息
  @impl true
  def handle_info({:report, worker_pid, status}, state) do
    IO.puts("收到Worker #{inspect(worker_pid)}的汇报：#{status}")
    {:noreply, state}
  end
end

defmodule XYZ.Worker do
  use GenServer

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

  @impl true
  def init(_opts) do
    # 通过全局名称直接拿Controller的PID
    case Process.whereis(XYZ.Controller) do
      controller_pid when is_pid(controller_pid) ->
        send(controller_pid, {:worker_ready, self()})
        {:ok, %{controller_pid: controller_pid}}
      _ ->
        # 如果Controller还没启动（理论上不会发生），直接退出
        {:stop, :controller_not_found}
    end
  end

  @impl true
  def handle_info(:do_work, state) do
    # 模拟工作后向Controller汇报
    send(state.controller_pid, {:report, self(), :working})
    {:noreply, state}
  end
end

如果不想用全局名称（比如怕命名冲突），可以用Elixir官方的Registry模块来动态注册和查找进程，灵活性更高。

defmodule XYZ.MySup do
  use Supervisor

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

  @impl true
  def init(_opts) do
    children = [
      # 先启动Registry服务，用来注册进程
      {Registry, keys: :unique, name: XYZ.ProcessRegistry},
      {XYZ.Controller, []},
      {XYZ.Worker, []}
    ]

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

defmodule XYZ.Controller do
  use GenServer

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

  @impl true
  def init(_opts) do
    # 把自己的PID注册到Registry，键为:main_controller
    Registry.register(XYZ.ProcessRegistry, :main_controller, nil)
    {:ok, %{}}
  end

  # 汇报处理逻辑和方案1一致
end

defmodule XYZ.Worker do
  use GenServer

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

  @impl true
  def init(_opts) do
    # 从Registry里查找Controller的PID
    case Registry.lookup(XYZ.ProcessRegistry, :main_controller) do
      [{controller_pid, _}] ->
        send(controller_pid, {:worker_ready, self()})
        {:ok, %{controller_pid: controller_pid}}
      [] ->
        {:stop, :controller_not_found}
    end
  end

  # 工作汇报逻辑和方案1一致
end

这个方案最可靠——让Controller所在的嵌套Supervisor先启动Controller，再把Controller的PID作为参数传给Worker，完全不需要Worker主动查找。

defmodule XYZ.RootSup do
  use Supervisor

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

  @impl true
  def init(_opts) do
    children = [
      # 启动Controller专属的嵌套Supervisor
      {XYZ.ControllerSup, []}
    ]

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

defmodule XYZ.ControllerSup do
  use Supervisor

  def start_link(opts) do
    Supervisor.start_link(__MODULE__, opts)
  end

  @impl true
  def init(_opts) do
    # 先启动Controller，拿到它的PID
    {:ok, controller_pid} = Supervisor.start_child(self(), {XYZ.Controller, []})

    # 给每个Worker传入Controller的PID作为启动参数
    worker_specs = for _ <- 1..3 do
      {XYZ.Worker, [controller_pid: controller_pid]}
    end

    # 批量启动Worker
    Enum.each(worker_specs, &Supervisor.start_child(self(), &1))

    # 用:rest_for_one策略，Controller挂了的话所有Worker跟着重启
    Supervisor.init([{XYZ.Controller, []} | worker_specs], strategy: :rest_for_one)
  end
end

defmodule XYZ.Controller do
  use GenServer

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

  @impl true
  def init(_opts) do
    {:ok, %{}}
  end

  # 汇报处理逻辑和之前一致
end

defmodule XYZ.Worker do
  use GenServer

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

  @impl true
  def init(%{controller_pid: controller_pid}) do
    # 直接拿到Controller的PID，不用查找
    send(controller_pid, {:worker_ready, self()})
    {:ok, %{controller_pid: controller_pid}}
  end

  # 工作汇报逻辑和之前一致
end

你说的“一次性启动所有进程后再传PID”，大概率是踩了这两个坑：

• 启动顺序问题：Supervisor虽然按列表顺序启动进程，但进程初始化是异步的，可能Worker先完成启动，此时Controller还没就绪，拿不到PID。
• 时机不对：等所有进程启动完再传PID时，Worker可能已经因为拿不到PID退出，或者没处理接收PID的逻辑。

上面的三个方案都从根源上解决了这两个问题，确保Worker启动时就能拿到有效的Controller PID。

内容的提问来源于stack exchange，提问作者mszmurlo