错误处理

让别人来修复某个错误而不是自己动手是个不错的主意，能够促进专业化。如果我需要做手术，就会去找大夫，而不是尝试自己操作

如果我的汽车出了点小问题，车上的控制电脑就会尝试修复它。如果修复失败、问题变得更棘手了，就必须把车拉到修理厂，让其他人来修理它

如果某个Erlang进程出了点小问题，可以尝试用 catch 或 try 语句来修复它。但如果修复失败，就应该直接崩溃，让其他进程来修复这个错误 

安排一些进程来互相监控各自的健康状况，如果一个进程挂了，其他某个进程就会注意到并采取纠正措施

这可以作为顺序代码错误处理的延伸：虽然可以捕捉顺序代码里的异常并尝试纠正错误，但如果失败了或者整台机器出了故障，就要让其他进程来修复错误

要让一个进程监控另一个，就必须在它们之间创建一个 连接 （ link ）或 监视 （ monitor ）：

• 如果被连接或监视的进程挂了，监控进程就会得到通知
• 监控进程必须实现 跨机器 的透明运作，因此运行在某一台机器上的进程可以监视运行在不同机器上进程的行为

这是编写容错式系统的基础：

不能在一台机器上构建容错式系统，因为崩溃的可能是整台机器，所以至少需要两台机器

一台机器负责计算，其他的机器负责监控它，并在第一台机器崩溃时接管计算 

如果来自C这样的语言，这听起来会非常奇怪。在C里，我们被教导要编写防御性代码，程序应当检查它们的参数以避免崩溃

在C里这么做很有必要：编写多进程代码极其困难，而绝大多数应用程序只有一个进程，所以如果这个进程让整个应用程序崩溃，麻烦可就大了

这意味着需要大量的错误检查代码，它们会和非错误检查代码交织在一起

在Erlang里，所做的恰恰相反。会把应用程序构建成两个部分：

• 一部分负责 解决问题 ：负责解决问题的部分会尽可能地少用防御性代码，并假设函数的所有参数都是正确的，程序也会正常运行
• 另一部分负责在 错误发生时纠正它们 ：纠正错误的部分往往是通用的，因此同一段错误纠正代码可以用在许多不同的应用程序里

如果数据库的某个事务出了错，就简单地中止该事务，让系统把数据库恢复到出错之前的状态

如果操作系统里的某个进程崩溃了，就让操作系统关闭所有打开的文件或套接字，然后让系统恢复到某个稳定状态

这么做让任务有了清楚的区分：编写解决问题的代码和修复错误的代码，但两者不会交织在一起。代码的体积可能会因此显著变小

进程有两种:

• 普通进程：spawn 创建的是普通进程
• 系统 进程：普通进程可以通过执行内置函数 process_flag(trap_exit, true) 变成系统进程

进程可以 互相连接

如果 A 和 B 两个进程有连接,而 A 出于某种原因终止了,就会向 B 发送一个错误信号,反之亦然

监视和连接很相似,但它是 单向 的

如果 A 监视 B ,而 B 出于某种原因终止了,就会向 A 发送一个“宕机”消息,但反过来就不行了

进程协作的方式是交换 消息 或 错误信号 ：

• 消息：通过基本函数 send 发送的
• 错误信号： 进程崩溃 或 进程终止 时自动发送的，错误信号会发送给 终止进程的连接组

通常,我们希望创建能够 同步终止 的 进程组 。在论证系统行为的时候,这是一个非常有用的不变法则：

• 当多个进程合作解决问题而某处出现问题时,有时候我们能进行恢复
• 但如果无法恢复,就会希望之前所做的一切事情都停止下来

它和事务(transaction)这个概念很像:进程要么做它们该做的事,要么全部被杀死

假设我们有一些相互连接的进程而其中的某个进程挂了,比如下图中的 P9 。图a展示了 P9终止前各个进程是如何连接的，图b展示了 P9 崩溃且所有错误信号都处理完成后还剩下哪些进程：

当 P9 终止时：

1. 一个错误信号被发送给进程 P4 和 P10 。因为 P4 和 P10 不是系统进程,所以也一起终止了
2. 随后,错误信号被发送给与它们相连的所有进程
3. 最后,错误信号扩散到了所有相连的进程,整个互连进程组都终止了

事实上：如果 P1 、 P3 、 P4 、 P9 或 P10 里的任意进程终止,它们就会全部终止

有时候我们不希望相连的进程全部终止,而是想让系统里的错误停止扩散。下图对此进行了演示,里面所有的相连进程都会终止,一直到 P3 为止：

要实现这一点, P3 可以执行 process_flag(trap_exit, true) 并转变成一个系统进程(意思是它可以捕捉退出信号)。如图b所示,它用双圆来表示

P9 崩溃之后,错误的扩散会在 P3 处停止,因此 P1 和 P3 不会终止

P3 充当了一个防火墙,阻止错误扩散到系统里的其他进程中

link(Pid) -> true

它会创建一个与进程 Pid 的连接：

• 连接是双向的：如果进程 A 执行了 link(B) ,就会与 B 相连，实际效果就和 B 执行 link(A) 一样
• 如果进程 Pid 不存在,就会抛出一个 noproc 退出异常
• 如果执行 link(B) 时 A 已经连接了 B (或者相反),这个调用就会被忽略

unlink(Pid) ->
    true. 

移除当前进程和进程 Pid 之间的所有连接

monitor(process, Item) ->
    Ref. 

它会设立一个监视：

• Item 可以是进程的 Pid ,也可以是它的 注册名称
• Ref: 该 进程的引用

如果这个进程因为 Why 的原因终止了,消息 {'DOWN',Ref,process,Pid,Why} 就会被发往 父进程

demonitor(Ref) ->
    true. 

移除以 Ref 作为引用的监视

process_flag(trap_exit, true). 

它会把当前进程转变成系统进程，系统进程是一种能 接收 和 处理 错误信号 的进程

exit(Why) ->
    none(). 

它会使当前进程因为 Why 的原因终止，如果执行这一语句的子句不在 catch 语句的范围内：

• 此进程就会向当前 连接的所有进程 广播 一个 带有参数 Why 的 退出信号
• 它还会向所有 监视它的进程 广播 一个 DOWN 消息

exit(Pid, Why) ->
    true. 

它会向进程 Pid 发送一个带有原因 Why 的退出信号 。执行这个内置函数的进程本身不会终止，它只是被用于模拟一个退出信号

可以用这些基本函数来设立互相监视的进程网络，并把它作为构建容错式软件的起点

函数 on_exit(Pid, Fun) 会监视进程 Pid ,如果它因为原因 Why 退出了,就会执行 Fun(Why) ：

on_exit(Pid, Fun) ->
    spawn(fun() -> 
                  Ref = monitor(process, Pid), 
                  receive
                      {'DOWN', Ref, process, Pid, Why} -> 
                          Fun(Why) 
                  end
          end).

• monitor(process, Pid) ：对 Pid 创建了一个监视
• 当这个进程终止时,监视进程就会接收一个 DOWN 消息并调用 Fun(Why)

为了测试它,现在来定义一个 F 函数,让它等待一个消息 X 然后计算 list_to_atom(X) :

F = fun() ->
            receive 
                    X -> list_to_atom(X)
                    end 
    end.

现在创建一个运行F的进程：

2> F = fun() -> receive X -> list_to_atom(X) end end.  
#Fun<erl_eval.20.50752066>
3>  
3> Pid = spawn(F) . 
<0.44.0>

设立一个 on_exit 处理进程来监视它：

4> lib_misc:on_exit(Pid, fun(Why) -> io_format(" ~p died with ~p~n", [Pid, Why]) end) . 
<0.46.0>

如果向 Pid 发送一个原子,这个进程就会挂掉(因为它试图对非列表类型执行 list_to_atom )，同时 on_exit 处理进程则会得到通知：

5> Pid ! hello . 
hello
6> 
6> 
=ERROR REPORT==== 18-Mar-2021::10:14:51 ===
Error in process <0.44.0> with exit value:
{badarg,[{erlang,list_to_atom,[hello],[]}]}

=ERROR REPORT==== 18-Mar-2021::10:14:51 ===
Error in process <0.46.0> with exit value:
{{shell_undef,io_format,2,[]},
 [{shell,shell_undef,2,[{file,"shell.erl"},{line,1059}]},
  {erl_eval,local_func,6,[{file,"erl_eval.erl"},{line,562}]}]}

进程挂掉时触发的函数可以执行任何它喜欢的计算:它可以忽略错误,记录错误或者重启应用程序

这个选择完全取决于程序员

假设要创建若干工作进程来解决某个问题,它们分别执行函数 F1, F2… 。如果任何一个进程挂了,我们希望它们能全体终止。可以调用 start([F1,F2, …]) 来实现这一点：

start(Fs) ->
    spawn(fun() ->
                  [spwan_link(F) || F <- Fs], 
                  receive 
                  after
                      infinity->
                          true
                  end
          end).

start(Fs): 会创建出一个进程，后者随即创建并连接各个工作进程，然后无限期等待

如果任何一个工作进程挂了,它们就都会终止

如果想知道这些进程是否都已终止,可以给启动进程添加一个 on_exit 处理进程：

Pid = start([F1, F2, ...]),
on_exit(Pid, fun(Why) ->
                                                %... 如果任何一个工作进程挂了
                                                %... 就执行这里的代码
                     true
             end) 

将生成一个持久运行的进程。具体做法是生成一个始终活动的注册进程,如果它出于任何原因挂了,就会立即重启

keep_alive(Name, Fun) ->
    register(Name, Pid = spawn(Fun)),
    on_exit(Pid, fun(_Why) -> keep_alive(Name, Fun) end).

这段代码生成一个名为 Name 的注册进程,并让它执行 spawn(Fun) ，如果这个进程出于任何原因挂了,就会被重启