Process Elixir，如何在单个主管的监督下运行多个流程

有一个由三个模块组成的程序。打印模块从键盘接收一个数字，将其传递给另一个模块，接收响应，并在屏幕上显示。Proc1和Proc2模块接收一个数字，执行计算，并将结果发送回

   defmodule Launch do
  @moduledoc """
  Documentation for `Launch`.
  """

  @doc """
  """
  def start() do
    children = [
      %{
        id: Print,
        start: {Print, :print, []}
      },
      %{
        id: Proc1,
        start: {Proc1, :proc1, []}
      },
      %{
        id: Proc2,
        start: {Proc2, :proc2, []}
      }
    ]

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

defmodule Print do
  def print() do
    num =
      IO.gets("Input number: ")
      |> String.trim()
      |> String.to_integer()

    if num >= 0 do
      send(Proc1, {self(), num})
    else
      send(Proc2, {self(), num})
    end

    receive do
      num -> IO.puts(num)
    after
      500 ->
        print()
    end
    print()
  end
end

defmodule Proc1 do
  def proc1() do
    receive do
      {pid, num} ->
        send(pid, 100/num)
        proc1()
      _e ->
        IO.puts("Error")
    end
  end
end

defmodule Proc2 do
  def proc2() do
    receive do
      {pid, num} ->
        send(pid, 1000/num)
        proc2()
      _e ->
        IO.puts("Error")
    end
  end
end

---

我试图在一名主管的监督下运行所有流程。但有一个问题，只有第一个“子”启动，其他“子”未启动。在上面的示例中，打印过程将启动，但Proc1和Proc2将不会启动。如何在一个主管下运行所有流程？重要提示：打印进程必须获取Proc1和Proc2进程的地址以进行通信。

您发布的代码存在许多问题

注册进程 要能够在调用中使用流程名称，应启动

Supervisor.start\u link/2

需要一个元组列表，其中包含立即返回的模块和函数，该过程作为副作用启动。这些函数都被调用了，不会有任何神奇之处：如果这是一个无限递归函数，那么执行流将在内部死锁，等待

receive/1

中的消息

Supervisor

通过自动监视和重新启动子进程来执行一些神奇的操作，但它不会产生单独的进程

GenServer

封装了此功能，并提供了一种简便的方法，不必担心生成进程

解决方案 您可能要做的是生成所有三个进程，手动监视它们，并对

{:DOWN，ref，：process，pid，reason}

消息作出反应，重新启动已死亡的进程。这正是

Supervisor

为儿童有效地做的事情

启动

defmodule-Launch-do
def start（）do
proc1=spawn（&proc1.proc1/0）
proc2=spawn（&proc2.proc2/0）
print=spawn（fn->print.print（proc1，proc2）结束）
进程监视器（proc1）
进程监视器（proc2）
进程监视器（打印）
接收do
msg->IO.inspect（msg）
结束
结束
结束

打印

defmodule-Print-do
def打印（pid1、pid2）do
num=
IO.gets（“输入编号：”）
|>String.trim（）
|>String.to_integer（）
如果num>=0，则执行以下操作
发送（pid1，{self（），num}）
其他的
发送（pid2，{self（），num}）
结束
接收do
num->IO.put（num）
结束
打印（pid1、pid2）
结束
结束

其他两个模块都很好

---

下面是它在iex中的样子

iex | 1▶ c“/tmp/test.ex”
#⇒[发布、打印、程序1、程序2]
iex | 2▶ 启动
输入号码：10
10
输入号码：1000
0.1
输入号码：a
#⇒{：向下，#参考，
#：进程，#PID，
#{：巴达格，
#          [
#{:erlang，：二进制到整数，[“a”]，[]}，
#{Print，：Print，2，[文件：'/tmp/test.ex'，行：22]}
#        ]}}

现在，不要将其打印出来，而是重新启动失败的流程，您将获得受监督的内部通信流程的简单实现。对于可以通过以下方式实现的

all\u For\u one

策略：

receive do
{：向下，{，}，{，}->
进程退出（打印，：正常）
进程退出（proc1，：正常）
进程退出（proc2，：正常）
开始（）
结束