实现使用监管者让其中一个进程重起十次

一、使用监管者让一个进程重新启动10次简单示例

在Erlang中，我们可以使用OTP的监管机制来重新启动一个进程。监管者（supervisor）是OTP的一个关键组件，它负责启动、停止、重启或者监控其子进程。

以下是一个简单的例子，展示了如何使用监管者来让一个进程重新启动10次：

-module(restart_process).  
-behaviour(supervisor).  
  
%% API  
-export([start_link/1]).  
  
start_link(Count) ->  
    supervisor:start_link({local, ?MODULE}, ?MODULE, Count).  
  
init(Count) ->  
    {ok, {{one_for_one, 5, 10}, {Count, []}}}.  
  
handle_info(Info, Count) ->  
    {restart, 1, 10, Info}.  
  
terminate(_Reason, _Count) ->  
    ok.

这个模块实现了一个简单的监管者。它使用supervisor:start_link/2来启动自己，并且接受一个参数Count，表示需要重启的次数。

(1)init/1函数用于初始化监管者的状态。在这里，我们使用了one_for_one的策略，意味着只要有一个子进程失败，监管者就会重启它。重启的次数限制为10次，每次重启间隔为5秒。

(2)handle_info/2函数处理子进程的退出信息。当子进程退出时，它会返回{restart, 1, 10, Info}，表示需要重启子进程，重启次数为1次，最大重启次数为10次，退出信息为Info。

(3)terminate/2函数在所有子进程都失败时被调用。在这里，我们只是简单地返回ok。

要使用这个模块，你可以这样调用：

1> c(restart_process).  
{ok,restart_process}  
2> restart_process:start_link(10).  
{ok,<0.30.0>}

这会启动一个进程，并尝试让它重新启动10次。如果你想在某个时刻停止重启动，可以调用exit(<0.30.0>, kill)来杀死这个进程。

二、使用监管者让一个购买进程重起十次的实例代码

1、定义一个购买进程的行为

首先，你需要定义一个购买进程的行为。这可以通过定义一个模块并实现gen_server行为模式来完成。代码如下：

-module(purchase).  
-behaviour(gen_server).  
  
%% API  
-export([start_link/1]).  
  
%% gen_server callbacks  
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2,   
         code_change/3]).  
  
start_link(Count) ->  
    gen_server:start_link({local, ?MODULE}, ?MODULE, [Count], []).  
  
init(Count) ->  
    {ok, {Count, 0}}.  
  
handle_call(_Request, _From, State) ->  
    {reply, ok, State}.  
  
handle_cast(_Msg, {Count, Remaining}) ->  
    {noreply, {Count, Remaining - 1}}.  
  
handle_info(_Info, State) ->  
    {noreply, State}.  
  
terminate(_Reason, _State) ->  
    ok.  
  
code_change(_OldVsn, State, _Extra) ->  
    {ok, State}.

这个模块实现了gen_server行为模式，并定义了一个start_link/1函数来启动购买进程。init/1函数初始化状态，包括剩余的尝试次数。handle_cast/2函数处理消息，这里我们简单地减少剩余尝试次数。如果尝试次数用完，购买进程应该被终止。

2.定义一个监管者的行为

接下来，我们需要定义一个supervisor的行为。Supervisors用于启动、监视和管理子进程。代码如下：

-module(purchase_supervisor).  
-behaviour(supervisor).  
  
%% API  
-export([start_link/0]).  
   
-export([init/1, start_child/2, stop/1]).  
  
start_link() ->  
    supervisor:start_link({local, ?MODULE}, ?MODULE, []).  
  
init(_Args) ->  
    {ok, {{one_for_one, 10000, 1}, { supervisor, {purchase, start_link, [10]}}} }  
    %% 使用购买模块的start_link功能重新启动流程10次.  
    %% 如果监控器终止，它将重新启动。最长重新启动时间为10秒。
    %% 关闭超时是无限的。策略是“one_for_one”，这意味着如果子进程终止，则只会重新启动该进程。  
}.  
  
start_child(Name, _Args) ->  
    %% 监管者不会直接调用子模块的启动函数。
    %% 相反，它们使用模块名称和参数调用application:start/2。   
    application:start(purchase).     %%  启动购买模块
   
    %% 子进程将链接到监管者，并将通过模块的启动功能启动。
    %% 如果子进程终止，将通知监管者，并使用init/1中定义的重新启动策略重新启动它。   
    %% 子进程命名为“购买”。  
    {ok, Pid} = purchase:start_link(10), %% 使用参数[10]启动购买模块。   
    {ok, Pid}. %% 返回子进程的Pid。   

stop(_Supervisor) -> ok. %% 当监管者被阻止时，不需要做任何事情。

这个模块实现了supervisor行为模式，并定义了start_link/0函数来启动supervisor。在init/1函数中，我们定义了重启策略和子进程的启动方式。当子进程终止时，supervisor会接收到通知，并按照在init/1中定义的策略进行重启。start_child/2函数用于启动子进程，并将其链接到supervisor。最后，stop/1函数用于停止supervisor。