Erlang入门（四）——错误处理和鲁棒性

去了趟福州，事情没搞定，托给同学帮忙处理了，回家休息了两天就来上班了。回家这几天最大的收获是第四次重读《深入Java虚拟机》，以前不大明了的章节豁然开朗，有种开窍的感觉，水到渠成，看来技术的学习还是急不来。
    闲话不提，继续Erlang的学习，上次学习到分布式编程的章节，剩下三章分别是错误处理、构造健壮的系统和杂项，错误处理和构造健壮的系统今天一起读了，仅摘记下。
    任何一门语言都有自己的错误处理机制，Erlang也不例外，语法错误编译器可以帮你指出，而逻辑错误和运行时错误就只有靠程序员利用Erlang提供的机制来妥善处理，放置程序的崩溃。
    Erlang的机制有：
1)监控某个表达式的执行
2）监控其他进程的行为
3）捕捉未定义函数执行错误等

一、catch和throw语句
    调用某个会产生错误的表达式会导致调用进程的非正常退出，比如错误的模式匹配（2=3），这种情况下可以用catch语句：

catch expression

试看一个例子，一个函数foo：

foo(1) ->
hello;
foo(2) ->
throw({myerror, abc});
foo(3) ->
tuple_to_list(a);
foo(4) ->
exit({myExit, 222}).

当没有使用catch的时候，假设有一个标识符为Pid的进程调用函数foo（在一个模块中），那么：
foo(1) - 返回hello
foo(2) - 语句throw({myerror, abc})执行，因为我们没有在一个catch中调用foo(2),因此进程Pid将因为错误而终止。

foo(3) - tuple_to_list将一个元组转化为列表，因为a不是元组，因此进程Pid同样因为错误而终止

foo(4) - 因为没有使用catch，因此foo(4)调用了exit函数将使进程Pid终止，{myExit, 222} 参数用于说明退出的原因。

foo(5) - 进程Pid将因为foo(5)的调用而终止，因为没有和foo(5)匹配的函数foo/1。

让我们看看用catch之后是什么样：

demo(X) ->
case catch foo(X) of
  {myerror, Args} ->
       {user_error, Args};
  {'EXIT', What} ->
       {caught_error, What};
  Other ->
       Other
end.

再看看结果，
demo(1) - 没有错误发生，因此catch语句将返回表达式结果hello
demo(2) - foo(2)抛出错误{myerror, abc}，被catch返回，因此将返回{user_error,abc}

demo(3) - foo(3)执行失败，因为参数错误，因此catch返回{'EXIT',badarg'},最后返回{caught_error,badarg}

demo(4) - 返回{caught_error,{myexit,222}}
demo(5) - 返回{caught_error,function_clause}

使用catch和throw可以将可能产生错误的代码包装起来，throw可以用于尾递归的退出等等。Erlang是和scheme一样进行尾递归优化的，它们都没有显式的迭代结构（比如for循环）

二、进程的终止
    在进程中调用exit的BIFs就可以显式地终止进程，exit(normal)表示正常终止，exit(Reason)通过Reason给出非正常终止的原因。进程的终止也完全有可能是因为运行时错误引起的。

三、连接的进程
    进程之间的连接是双向的，也就是说进程A打开一个连接到B,也意味着有一个从B到A的连接。当进程终止的时候，有一个EXIT信号将发给所有与它连接的进程。信号的格式如下：
               {'EXIT', Exiting_Process_Id, Reason} 
Exiting_Process_Id 是指终止的进程标记符
Reason 是进程终止的原因。如果Reason是normal，接受这个信号的进程的默认行为是忽略这个信号。默认对Exit信号的处理可以被重写，以允许进程对Exit信号的接受做出不同的反应。
1.连接进程：
通过link(Pid)，就可以在调用进程与进程Pid之间建立连接
2.取消连接
反之通过unlink(Pid)取消连接。 
3.创立进程并连接：
通过spawn_link(Module, Function, ArgumentList)创建进程并连接，该方法返回新创建的进程Pid

通过进程的相互连接，许多的进程可以组织成一个网状结构，EXIT信号（非normal)从某个进程发出（该进程终止），所有与它相连的进程以及与这些进程相连的其他进程，都将收到这个信号并终止，除非它们实现了自定义的EXIT信号处理方法。一个进程链状结构的例子：

-module(normal).
-export([start/1, p1/1, test/1]).
start(N) ->
register(start, spawn_link(normal, p1, [N - 1])).
 p1(0) ->
   top1();
 p1(N) ->
   top(spawn_link(normal, p1, [N - 1]),N).
top(Next, N) ->
receive
X ->
Next ! X,
io:format("Process ~w received ~w~n", [N,X]),
top(Next,N)
end.
top1() ->
receive
stop ->
io:format("Last process now exiting ~n", []),
exit(finished);
X ->
io:format("Last process received ~w~n", [X]),
top1()
end.
test(Mess) ->
start ! Mess.

执行：

> normal:start(3).
true
> normal:test(123).
Process 2 received 123
Process 1 received 123
Last process received 123

> normal:test(stop).
Process 2 received stop
Process 1 received stop
Last process now exiting
stop

四、运行时失败
    一个运行时错误将导致进程的非正常终止，伴随着非正常终止EXIT信号将发出给所有连接的进程，EXIT信号中有Reason并且Reason中包含一个atom类型用于说明错误的原因，常见的原因如下：

badmatch - 匹配失败，比如一个进程进行1=3的匹配，这个进程将终止，并发出{'EXIT', From, badmatch}信号给连接的进程

badarg  - 顾名思义，参数错误，比如atom_to_list(123),数字不是atom，因此将发出{'EXIT', From, badarg}信号给连接进程

case_clause - 缺少分支匹配，比如

M = 3,
case M of
  1 ->
    yes;
  2 ->
    no
end.

没有分支3，因此将发出{'EXIT', From, case_clause}给连接进程

if_clause - 同理，if语句缺少匹配分支

function_clause - 缺少匹配的函数，比如：

foo(1) ->
  yes;
foo(2) ->
  no.

如果我们调用foo(3)，因为没有匹配的函数，将发出{'EXIT', From, function_clause} 给连接的进程。

undef - 进程执行一个不存在的函数

badarith - 非法的算术运算，比如1+foo。

timeout_value - 非法的超时时间设置，必须是整数或者infinity

nocatch - 使用了throw，没有相应的catch去通讯。

五、修改默认的信号接收action
   当进程接收到EXIT信号，你可以通过process_flag/2方法来修改默认的接收行为。执行process_flag(trap_exit,true)设置捕获EXIT信号为真来改变默认行为，也就是将EXIT信号作为一般的进程间通信的信号进行接受并处理；process_flag(trap_exit,false)将重新开启默认行为。
   例子：

-module(link_demo).
-export([start/0, demo/0, demonstrate_normal/0, demonstrate_exit/1,
demonstrate_error/0, demonstrate_message/1]).
start() ->
  register(demo, spawn(link_demo, demo, [])).
demo() ->
  process_flag(trap_exit, true),
demo1().
  demo1() ->
  receive
    {'EXIT', From, normal} ->
      io:format("Demo process received normal exit from ~w~n",[From]),
     demo1();
    {'EXIT', From, Reason} ->
      io:format("Demo process received exit signal ~w from ~w~n",[Reason, From]),
     demo1();
    finished_demo ->
      io:format("Demo finished ~n", []);
    Other ->
      io:format("Demo process message ~w~n", [Other]),
     demo1()
  end.
demonstrate_normal() ->
  link(whereis(demo)).
demonstrate_exit(What) ->
  link(whereis(demo)),
  exit(What).
demonstrate_message(What) ->
  demo ! What.
demonstrate_error() ->
  link(whereis(demo)),
  1 = 2.

创建的进程执行demo方法，demo方法中设置了trap_exit为true,因此，在receive中可以像对待一般的信息一样处理EXIT信号，这个程序是很简单了，测试看看：

> link_demo:start().
true
> link_demo:demonstrate_normal().
true
Demo process received normal exit from <0.13.1>
> link_demo:demonstrate_exit(hello).
Demo process received exit signal hello from <0.14.1>
** exited: hello **

> link_demo:demonstrate_exit(normal).
Demo process received normal exit from <0.13.1>
** exited: normal **

> link_demo:demonstrate_error().
!!! Error in process <0.17.1> in function
!!! link_demo:demonstrate_error()
!!! reason badmatch
** exited: badmatch **
Demo process received exit signal badmatch from <0.17.1>

六、未定义函数和未注册名字
1.当调用一个未定义的函数时，Mod:Func(Arg0,...,ArgN)，这个调用将被转为：
error_handler:undefined_function(Mod, Func, [Arg0,...,ArgN]) 
其中的error_handler模块是系统自带的错误处理模块

2.当给一个未注册的进程名发送消息时，调用将被转为：
error_handler:unregistered_name(Name,Pid,Message)

3.如果不使用系统自带的error_handler，可以通过process_flag(error_handler, MyMod) 设置自己的错误处理模块。

七、Catch Vs. Trapping Exits
这两者的区别在于应用场景不同，Trapping Exits应用于当接收到其他进程发送的EXIT信号时，而catch仅用于表达式的执行。

第8章介绍了如何利用错误处理机制去构造一个健壮的系统，用了几个例子，我将8.2节的例子完整写了下，并添加客户端进程用于测试：

-module(allocator).
-export([start/1,server/2,allocate/0,free/1,start_client/0,loop/0]).
start(Resources) ->
   Pid = spawn(allocator, server, [Resources,[]]),
register(resource_alloc, Pid).
%函数接口
allocate() ->
   request(alloc).
free(Resource) ->
  request({free,Resource}).
request(Request) ->
  resource_alloc ! {self(),Request},
  receive
    {resource_alloc, error} ->
      exit(bad_allocation); % exit added here
    {resource_alloc, Reply} ->
      Reply
 end.
% The server.
server(Free, Allocated) ->
 process_flag(trap_exit, true),
 receive
   {From,alloc} ->
         allocate(Free, Allocated, From);
   {From,{free,R}} ->
        free(Free, Allocated, From, R);
   {'EXIT', From, _ } ->
       check(Free, Allocated, From)
 end.
allocate([R|Free], Allocated, From) ->
   link(From),
   io:format("连接客户端进程~w~n",[From]),
   From ! {resource_alloc,{yes,R}},
   server(Free, [{R,From}|Allocated]);
allocate([], Allocated, From) ->
   From ! {resource_alloc,no},
   server([], Allocated).
free(Free, Allocated, From, R) ->
  case lists:member({R,From}, Allocated) of
   true ->
              From ! {resource_alloc,ok},
              Allocated1 = lists:delete({R, From}, Allocated),
              case lists:keysearch(From,2,Allocated1) of
                     false->
                            unlink(From),
                        io:format("从进程~w断开~n",[From]);
                     _->
                            true
              end,
             server([R|Free],Allocated1);
   false ->
           From ! {resource_alloc,error},
         server(Free, Allocated)
 end.

check(Free, Allocated, From) ->
   case lists:keysearch(From, 2, Allocated) of
         false ->
           server(Free, Allocated);
        {value, {R, From}} ->
           check([R|Free],
           lists:delete({R, From}, Allocated), From)
end.
start_client()->
    Pid2=spawn(allocator,loop,[]),
    register(client, Pid2).
loop()->
    receive
        allocate->
            allocate(),
            loop();
        {free,Resource}->
            free(Resource),
            loop();
        stop->
            true;
        _->
            loop()
    end.
    

回家了，有空再详细说明下这个例子吧。执行：

1> c(allocator).
{ok,allocator}
2> allocator:start([1,2,3,4,5,6]).
true
3> allocator:start_client().
true
4> client!allocate
.
allocate连接客户端进程<0.37.0>

5> client!allocate.
allocate连接客户端进程<0.37.0>

6> client!allocate.
allocate连接客户端进程<0.37.0>

7> allocator:allocate().
连接客户端进程<0.28.0>
{yes,4}
8> client!{free,1}.
{free,1}
9> client!{free,2}.
{free,2}
10> client!allocate.
allocate连接客户端进程<0.37.0>

11> client!allocate.
allocate连接客户端进程<0.37.0>

12> client!stop.
stop
13> allocator:allocate().
连接客户端进程<0.28.0>
{yes,3}
14> allocator:allocate().
连接客户端进程<0.28.0>
{yes,2}
15> allocator:allocate().
连接客户端进程<0.28.0>
{yes,1}
16>