3个监察被称为子进度的其余进度的长河

描述,工作者进程通常的实现使用gen

gen_server

概要

概要
  通用服务器行为
描述

  通用监督者行为

  行为模块达成服务器的客户端-服务器涉及。3个通用的服务器进程使用那些模块将落到实处1组正式的接口成效,包含追踪和错误报告功用。它也适合OTP进程监察和控制树。精晓越来越多消息参考OTP设计原则。

 

  gen_server假定全部特定部分位于2个回调模块,它导出的壹组预约义的成效。行为函数和回调函数的关联得以印证如下:

描述

  gen_server module Callback module
  —————– —————
  gen_server:start_link —–> Module:init/1

  1个兑现监督者的行为模块,一个监督被称为子进程的别的进度的经过。3个子进程可以是另2个监督者或工小编经过。工小编经过平时的贯彻利用gen_event,gen_fsm和gen_server中的行为。监督者使用这几个模块实现壹组正式的接口函数和包涵追踪和错误报告的作用。监督者被用来构建称为监察和控制树的分段进程组织,二个营造容错应用的很好的情势。参考OTP设计原理得到更多新闻。

  gen_server:call
  gen_server:multi_call —–> Module:handle_call/3

 

  gen_server:cast
  gen_server:abcast     —–> Module:handle_cast/2

  监督者设定哪些子进度被监察和控制的概念,位于导出1组预约义函数的回调模块。

  -               —–> Module:handle_info/2

 

  -               —–> Module:terminate/2

  除非另作申明,倘使内定的supervisor不设有或提交错误参数,该模块全体函数会失败。

  -               —–> Module:code_change/3

 

  借使一个回调函数战败或回到一个谬误的值,gen_server将会停下。

  监督规则:

  gen_server管理系统音讯,它们记录在sys。sys模块能够用来调解gen_server。

  监督者肩负运维、截止和监察和控制它的子进度。监督者的中坚理念是,它应当保证它的子进程活着,要求时重启它们。

  请注意,gen_server并不自动地破获退出功率信号,那么些必须旗帜明显地在回调模块运营。

 

  除非另作注脚,假设钦赐的gen_server不存在或提交错误参数,该模块全数函数会战败。

  监督者的子进度被定义为子标准列表。当监督者被运转时,子进程凭仗这些列表从左到右按梯次被运维。当监督者终止时,它首先按相反的起步顺序,从右到左终止它的子进程。

  假设贰个回调函数钦定”hibernate”而不是超时值,该gen_server进度会进来休眠。那也许是有效的,如若服务器估摸闲置不长一段时间。不过那么些效用应该小心使用,使用休眠意味着至少有七个废物搜聚(休眠又快速唤起),不是您想做的作业里面,每一趟调用八个繁忙的服务器。

 

导出

  监督者能够有以下重启攻略之1:

start_link(Module, Args, Options) -> Result
start_link(ServerName, Module, Args, Options) -> Result
  Types:
    ServerName = {local,Name} | {global,GlobalName} | {via,Module,ViaName}
      Name = atom()
      GlobalName = ViaName = term()
    Module = atom()
    Args = term()
    Options = [Option]
      Option = {debug,Dbgs} | {timeout,Time} | {spawn_opt,SOpts}
      Dbgs = [Dbg]
        Dbg = trace | log | statistics | {log_to_file,FileName} | {install,{Func,FuncState}}
      SOpts = [term()]
    Result = {ok,Pid} | ignore | {error,Error}
      Pid = pid()
      Error = {already_started,Pid} | term()

  one_for_one –
如若实进程终止,应重新启航,唯有子进程遭到震慑。

  创制2个gen_server进度作为监察和控制树的壹有的。函数应该一贯或直接地被supervisor调用。它将保险gen_server在其余方面被链接到supervisor。

  one_for_all –
若是实进程终止,应重新起动,全数别的子进程终止,那么富有的子进度被运维。

  gen_server进度调用Module:init/一举行初始化。为力保同步运营进度,start_link/3,四直到Module:init/壹施行到位才能再次来到。

  rest_for_one –
假设实进度终止,应重新起动,后边的子进度,也正是说,按运行顺序,被终止进度的前面包车型大巴子进程被甘休。那么,终止进度和它背后全部的子进度被重启。

  如果ServerName={local,Name},gen_server使用register/2被注册为地面包车型地铁Name。若是ServerName={global,GlobalName},gen_server使用global:register_name/2被登记为大局的GlobalName。假如未有提供Name,gen_server不会被登记。借使ServerName={via,Module,ViaName},gen_server将会用Module代表的注册表注册。Module回调应该导出函数register_name/2,
unregister_name/1, whereis_name/一 和
send/贰,它们表现得像global模块对应的函数。因而,{via,global,GlobalName}是1个使得地引用。

  simple_one_for_one –
简化的one_for_one监督者,个中,全数的子进度被动态增加同样过程类型的实例,也等于,运维同样的代码。

  Module是回调模块的称呼。

 

  Args是放肆term,作为参数字传送递给Module:init/一。

  对于simple_one_for_one监督者,函数delete_child/2 和
restart_child/二是卓有效能的。假若钦定的监督者使用该重启战略,会回去{error,simple_one_for_one}。

  假如选拔是{timeout,Time},gen_server被允许开销Time皮秒伊始化,可能它将被终止,并且运营函数再次回到{error,timeout}。
  即使选拔是{debug,Dbgs},对于Dbgs里的各样条目款项,对应的sys函数将会被调用。参见sys。
  如若选取是{spawn_opt,SOpts},SOpts将被作为选项列表传递给spawn_opt内建函数,它被用来发出gen_server。

 

  如果gen_server被成功创办和开头化,函数重回{ok,Pid},在那之中Pid是gen_server的进度号。假设已经存在使用钦定ServerName的历程,函数重返{error,{already_started,Pid}},当中,Pid是不行进度的进度号。

  在simple_one_for_one监督者下,通过给定子进度的经过号作为第四个参数,函数terminate_child/二可被用于子进度。假诺实标准标志符被使用,terminate_child/2将返回{error,simple_one_for_one}。

  如若Module:init因为Reason失败,函数再次回到{error,Reason}。假如Module:init/壹再次回到{stop,Reason}
或 ignore,进程被终止并且函数会分别重临{error,Reason} 或 ignore。

 

start(Module, Args, Options) -> Result
start(ServerName, Module, Args, Options) -> Result
  Types:
    同 start_link/3,4。

  因为1个simple_one_for_one监督者可以有诸多的子进度,它在同临时间将它们关闭。所以,它们被终止的顺序未有被定义。出于同样的缘故,它大概有一个付出对于关闭战略。

  创制三个独立的gen_server进程,也就是,gen_server不是监控树的一片段还要未有监察和控制进度。

 

  参看start_link/3,④打听参数和重返值的描述。

  为严防监督者进入子进度终止和重启的无比循环,使用多个整数Max卡宴 和
马克斯T定义最大重启频率。倘诺在马克斯T秒重启超越马克斯冠道爆发,监督者终止全数子进度,随后停下它协调。

call(ServerRef, Request) -> Reply
call(ServerRef, Request, Timeout) -> Reply
  Types:
    ServerRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
      Node = atom()
      GlobalName = ViaName = term()
    Request = term()
    Timeout = int()>0 | infinity
    Reply = term()

 

  通过发送请求向引用名称叫ServerRef的gen_server实行共同调用,直到回复达到或爆发超时。gen_server将调用Module:handle_call/三管理请求。

  那是子规范的类型定义:

  ServerRef可以是:

child_spec() = {Id,StartFunc,Restart,Shutdown,Type,Modules}
  Id = term()
  StartFunc = {M,F,A}
    M = F = atom()
     A = [term()]
   Restart = permanent | transient | temporary
   Shutdown = brutal_kill | int()>0 | infinity
   Type = worker | supervisor
   Modules = [Module] | dynamic
    Module = atom()
  • 进程号;
  • Name,gen_server被地面注册的称谓;
  • {Name,Node},gen_server在其余节点被本地注册;
  • {global,GlobalName},gen_server被全局注册;
  • {via,Module,ViaName},gen_server通过代表的长河注册表注册;

  
Id是1个称呼,在中间被监督者用于标志子标准。

  Request是五个大四term,它当做内部的参数字传送递给Module:handle_call/3。

  

  Timeout是2个超越零的整数,它内定多少阿秒等待每一种回复,原子infinity会Infiniti制时间的等候。私下认可值是5000。借使在指定期间内未有接收回复,函数会调用战败。借使调用者捕获战败并且接二连三运转,服务器仅仅晚些回复,它就要其他时候到达随后进入调用者的新闻队列。对此,调用者必须盘算那种场所,并且不保留任何杂质新闻,它们是多少个要素元组作为第一个成分。

  
StartFunc定义函数调用用于运营子进度。它应有是多少个模块-函数-参数元组{M,F,A}用作apply(M,F,A)。

  重临值Reply被定义在Module:handle_call/三的回到值里。

  
运行函数必须创建和链接到子进程,应该回到{ok,Child}或{ok,Child,Info},在那之中Child是子进程的过程号,Info是自便term被监督者忽略。

  调用恐怕会因为二种原因战败,蕴涵超时和在调用前和调用进程中gen_server死掉。

 

  在调用时期当连接到客户端,要是服务器死掉,有时会消耗退出音讯,那一个过时的行事已经在OTP
XC901二B/Erlang 5.陆中移除。

  
假如实进程因为有的缘由无法运维,运营函数也能够再次回到ignore,那种情景,子规范将会被监督者保存(除非它是temporary进程),但不存在的子过程将被忽略。

multi_call(Name, Request) -> Result
multi_call(Nodes, Name, Request) -> Result
multi_call(Nodes, Name, Request, Timeout) -> Result
  Types:
    Nodes = [Node]
      Node = atom()
    Name = atom()
    Request = term()
    Timeout = int()>=0 | infinity
    Result = {Replies,BadNodes}
      Replies = [{Node,Reply}]
        Reply = term()
      BadNodes = [Node]

 

  对具备在钦点节点上被地面注册为Name的gen_server进行联合调用,通过第一次发送请求到每一个节点,然后等待恢复。那一个gen_server进程将会调用Module:handle_call/3管理请求。

  
要是出现错误,函数也或然回到错误元组{error,Error}。

  函数重临元组{Replies,BadNodes},个中,Replies是{Node,Reply}的列表,BadNodes是不设有节点的列表,或gen_server
Name不存在或尚未过来。

 

  Nodes是伸手被发送到的节点名称列表。暗许值是中兼有已知的节点列表[node()|nodes()]。

  
请注意,start_link函数,不相同的作为模块满足上述的要求。

  Name是每个gen_server被地面注册的称谓。

 

  Request是3个放肆term,它作为在那之中的参数字传送递给Module:handle_call/3。

  
Restart定义哪一天甘休的子进程应该被重启。叁个permanent子进度应该总是被重启,二个temporary子进程未有被重启(即便当监督者的重启战略是rest_for_one或one_for_all和兄弟进程的挂掉导致temporary进度被甘休),和七个transient子进程应该被重启仅当它可怜终止,也便是说,除过normal,shutdown或{shutdown,Term}的其它退出原因。

  Timeout是四个不止零的整数,它钦定多少纳秒等待各类回复,原子infinity会无限制期限的等候。暗中认可值是infinity。假诺在指定时期内节点未有收受回复,该节点被投入到BadNodes。
当在节点Node来自gen_server回复Reply达到,{Node,Reply}被投入到Replies。Reply被定义在Module:handle_call/叁的归来值里。

 

  为制止随后的答疑(在逾期过后)污染调用者的新闻队列,二当中档人经过被用来狠抓际的调用。当它们达到1个停下的进度,迟到的回涨将不会被保存。

  
Shutdown定义子进度应该怎么着被终止。brutal_kill意味着子进程将被白白结束使用exit(Child,kill)。2个整数超时值意味着监督者将告诉子进程经过调用exit(Child,shutdown)来终止,然后以原因shutdown等待来自子进程的脱离功率信号。借使在钦定数量纳秒内尚未收受退出时域信号,子进度使用exit(Child,kill)被白白截止。

cast(ServerRef, Request) -> ok
  Types:
  ServerRef = Name | {Name,Node} | {global,GlobalName} | {via,Module,ViaName} | pid()
    Node = atom()
    GlobalName = ViaName = term()
  Request = term()

 

  发送一个异步请求到引用名ServerRef的gen_server,然后立即回到ok,如若目的节点或gen_server不设有,忽略新闻。gen_server将调用Module:handle_cast/二处理请求。

  
倘使实进度是另七个监督者,Shutdown应该被设置成infinity,给子树丰富的年月关闭。假使实进程是劳力,它也被允许设置成infinity。

  参看call/2,3,了解ServerRef的描述。

 

  Request是三个大4term,它看作内部的参数字传送递给Module_cast/2。

  
警告:小心设置shutdown战略为infinity,当子进度是三个劳引力。因为,在那种景观下,监控树的截止取决于子进度,它必须以安全的章程贯彻,它的清理进度必须重返。

abcast(Name, Request) -> abcast
abcast(Nodes, Name, Request) -> abcast
  Types:
    Nodes = [Node]
      Node = atom()
    Name = atom()
    Request = term()

 

  发送叁个异步请求给在内定节点被地面注册为Name的gen_server。函数立刻赶回并且忽略不设有的节点,或gen_server
Name不存在。gen_server将调用Module:handle_cast/二管理请求。

  
请注意,全部子进度自动使用规范OTP行为模块达成基于关闭协议。

  参看 multi_call/二,三,4,领会参数描述。

 

reply(Client, Reply) -> Result
  Types:
    Reply = term()
    Result = term()

  
Type钦定子进程是监督者依旧工作者。

  当回复没有定义在Module:handle_call/三的回来值里,该函数能够被gen_server用来显式地发送过来给二个调用
call/二,3 或 multi_call/2,三,四的客户端。

 

  Client必须是提须求回调函数的From参数。Reply是多个放4term,它将用作call/二,三或 multi_call/2,三,4的再次来到值被还原到客户端。

  
Modules被版本处理程序使用,在代码替换时期用于分明哪些进程使用什么模块。作为二个经验法则,Modules应该二个要素列表[Module],在那之中,Module是回调模块,假诺子进度是3个supervisor,
gen_server 或
gen_fsm。假诺实进度是一个富含回调模块集结的事件处理器(gen_event),Modules应该是dynamic。关于版本调节的越多新闻参考OTP设计基准。

  再次回到Result未有被进一步定义,并且应该总是被忽略。

 

enter_loop(Module, Options, State)
enter_loop(Module, Options, State, ServerName)
enter_loop(Module, Options, State, Timeout)
enter_loop(Module, Options, State, ServerName, Timeout)
  Types:
    Module = atom()
    Options = [Option]
      Option = {debug,Dbgs}
        Dbgs = [Dbg]
          Dbg = trace | log | statistics | {log_to_file,FileName} | {install,{Func,FuncState}}
    State = term()
    ServerName = {local,Name} | {global,GlobalName} | {via,Module,ViaName}
      Name = atom()
      GlobalName = ViaName = term()
    Timeout = int() | infinity

  
内部地,监督者也追踪子进度的长河号,或undefined要是未有经过号存在。

  使3个已存在的历程进入一个gen_server。不回来,反而这几个调用进度将跻身gen_server的选拔循环,并成为多少个gen_server进程。那几个历程必须运用proc_lib的启航函数被运转。用户为该进度的此外伊始化担当,包涵为它注册三个名字。

 

  这一个函数非常有用,当必要贰个更为复杂的早先化进度,而不是gen_server行为提供的。

数据类型

  Module,Option
和ServerName与调用gen_server:start[_link]/3,四具有同样的含义。然则,要是ServerName被内定,进度必须在该函数被调用前相应地被注册。

child() = undefined | pid()
child_id() = term() %% 不是pid()
child_spec() = 
     {Id :: child_id(),
      StartFunc :: mfargs(),
      Restart :: restart(),
      Shutdown :: shutdown(),
      Type :: worker(),
      Modules :: modules()}
    mfargs() = {M :: module(), F :: atom(), A :: [term()] | undefined} %% 如果Restart是temporary,A的值为undefined。
    modules() = [module()] | dynamic
    restart() = permanent | transient | temporary
    shutdown() = brutal_kill | timeout()
    strategy() = one_for_all | one_for_one | rest_for_one | simple_one_for_one
    sup_ref() = (Name :: atom())
          | {Name :: atom(), Node :: node()}
          | {global, Name :: atom()}
          | {via, Module :: module(), Name :: any()}
          | pid()
    worker() = worker | supervisor

  State和Timeout与Module:init/1的重回值有着同样的意思。回调模块Module也不必要导出贰个init/1函数。

 

  退步:假设调用进程未被一个proc_lib函数运营,恐怕1旦它未依据ServerName注册。

导出

回调函数

start_link(Module, Args) -> startlink_ret()
start_link(SupName, Module, Args) -> startlink_ret()
Types:
  SupName = sup_name()
  Module = module()
  Args = term()
  startlink_ret() = {ok, pid()} | ignore | {error, startlink_err()}
  startlink_err() = {already_started, pid()} | {shutdown, term()} | term()
    sup_name() = {local, Name :: atom()} | {global, Name :: atom()} | {via, Module :: module(), Name :: any()} 
Module:init(Args) -> Result
  Types:
    Args = term()
    Result = {ok,State} | {ok,State,Timeout} | {ok,State,hibernate} | {stop,Reason} | ignore
      State = term()
      Timeout = int()>=0 | infinity
      Reason = term()

  创设2个监督者进度作为监察和控制树的一有的,在另内地点,函数将保障监督者链接到调用者进度(它的监督者)。

  无论何时八个gen_server使用gen_server:start/3,4 或
gen_server:start_link/三,四被运营,该函数被3个新进程调用去伊始化。

 

  Args是提须求运行函数的参数。

  被创立的监督者进度调用Module:init/一寻觅重启战术、最大运行频率和子进度。为确定保障龄球联合会面运营进程,start_link/2,3不会回去直到Module:init/一已经回到且全数子进度已被运转。

  假诺开头化成功,函数应该回到{ok,State}, {ok,State,提姆eout} 或
{ok,State,hibernate},在那之中,State是gen_server的当中景色。

 

  若是一个整数超时值被提供,三个逾期将时有爆发,除非在Timeout阿秒内收取3个伸手或新闻。二个超时被timeout原子标志,它应该被handle_info/贰遍调函数处理。infinity能够被用来Infiniti时地等候,那是暗中认可值。

  假使SupName={local,Name},supervisor使用register/二被登记为当地的Name。要是SupName={global,Name},supervisor使用global:register_name/二被登记为全局的Name。假使未有提供Name,supervisor不会被注册。假如SupName={via,Module,ViaName},supervisor将会用Module代表的注册表注册。Module回调应该导出函数register_name/2,
unregister_name/1, whereis_name/1 和
send/贰,它们表现得像global模块对应的函数。由此,{via,global,Name}是一个一蹴而就地引用。

  假诺hibernate被钦赐而不是3个超时值,进度将进入休眠当等待下一条新闻到达时(调用proc_lib:hibernate/3)。

 

  若是在开端化时期出现错误,函数重返{stop,Reason},个中,Reason是任何term,或ignore。

  假诺未有提供名称,监督者不会登记。

Module:handle_call(Request, From, State) -> Result
  Types:
    Request = term()
    From = {pid(),Tag}
    State = term()
    Result = {reply,Reply,NewState} | {reply,Reply,NewState,Timeout} | {reply,Reply,NewState,hibernate}
      | {noreply,NewState} | {noreply,NewState,Timeout} | {noreply,NewState,hibernate}
      | {stop,Reason,Reply,NewState} | {stop,Reason,NewState}
      Reply = term()
      NewState = term()
      Timeout = int()>=0 | infinity
      Reason = term()

 

  无论曾几何时使用gen_server:call/2,3 或
gen_server:multi_call/2,3,4,gen_server接收请求发送,该函数被调用管理请求。

  Module是回调模块的名号。

  Request是提供给call或multi_call的参数。

 

  From是三个元组{Pid,Tag},个中,Pid是客户端的长河号,Tag是2个唯1标识。

  Args是一个率性term,作为参数字传送递给Module:init/一。

  State是gen_server的当中景况。

 

  要是函数再次来到{reply,Reply,NewState}, {reply,Reply,NewState,Timeout}
或 {reply,Reply,NewState,hibernate},Reply将被还原给From作为call/二,三 或
multi_call/2,三,4的重临值。然后gen_server继续实践,可能更新内部情状NewState。参看Module:init/一驾驭Timeout和hibernate的叙说。

  假如监督者和它的子进程被成功开创,(也正是说,如果全数子进度运维函数重回{ok,Child},
{ok,Child,Info}, 或
ignore)函数再次回到{ok,Pid},当中Pid是监督者的进度号。假诺已存在钦定SupName的长河,函数重临{error,{already_started,Pid}},个中,Pid是1贰分进度的进度号。

  借使函数重回{noreply,NewState}, {noreply,NewState,提姆eout} 或
{noreply,NewState,hibernate},gen_server将用NewState继续推行。任何对From的过来必须显式使用gen_server:reply/2。

 

  即使函数重回{stop,Reason,Reply,NewState},Reply将回涨给From。如若函数重返{stop,Reason,NewState},任何对From的回涨必须显式使用gen_server:reply/二。然后,函数将调用Module:terminate(Reason,NewState),随后停下。

  假诺Module:init/壹重返ignore,该函数也回到ignore,而监督者以原因normal终止。若是Module:init/一失利或回到不无误的值,该函数再次来到{error,Term},当中,Term是含有关于错误消息的Term,监督者以原因Term终止。

Module:handle_cast(Request, State) -> Result
  Types:
    Request = term()
    State = term()
    Result = {noreply,NewState} | {noreply,NewState,Timeout} | {noreply,NewState,hibernate} | {stop,Reason,NewState}
      NewState = term()
      Timeout = int()>=0 | infinity
      Reason = term()

 

  无论哪天,gen_server接收一个请求发送使用gen_server:cast/2 或
gen_server:abcast/贰,叁,该函数被调用管理请求。

  尽管任何子进度运维函数是败退或回到3个不当元组或贰个荒唐值,监督者首先将以原因shutdown终止全体已运转的历程,随后停下它协和,然后回来{error,
{shutdown, Reason}}。

  参见Module:handle_call/三驾驭参数和或者重临值的叙述。

 

Module:handle_info(Info, State) -> Result
  Types:
    Info = timeout | term()
    State = term()
    Result = {noreply,NewState} | {noreply,NewState,Timeout} | {noreply,NewState,hibernate} | {stop,Reason,NewState}
      NewState = term()
      Timeout = int()>=0 | infinity
      Reason = normal | term()
start_child(SupRef, ChildSpec) -> startchild_ret()
Types:
  SupRef = sup_ref()
  ChildSpec = child_spec() | (List :: [term()])
  child_spec() = 
      {Id :: child_id(),
       StartFunc :: mfargs(),
       Restart :: restart(),
       Shutdown :: shutdown(),
       Type :: worker(),
       Modules :: modules()}
  startchild_ret() = {ok, Child :: child()} | {ok, Child :: child(), Info :: term()} | {error, startchild_err()}
  startchild_err() = already_present | {already_started, Child :: child()} | term()

  该函数被gen_server调用,当超时产生或接收到其余音信而不是联合签字或异步请求(只怕系统新闻)。

  动态扩充3个子标准到监督者SuperRef,它运行相应的子进度。

  Info是原子timeout,当超时产生,或是已吸收接纳的音信。

  ServerRef可以是:

Module:terminate(Reason, State)
  Types:
    Reason = normal | shutdown | {shutdown,term()} | term()
    State = term()    

– 进程号;

Name,supervisor被本地注册的名称;
  • {Name,Node},supervisor在任何节点被地面注册;
  • {global,Name},supervisor被全局注册;
  • {via,Module,ViaName},supervisor通过代表的进程注册表注册。

 

  ChildSpec应该是实用的子进度(除非该监督者是一个simple_one_for_one的监督者,看下边)。子进程将会采用定义在子规范的启航函数运营。

 

  如果是simple_one_for_one监督者的动静下,定义在Module:init/一的子标准将被选用,ChildSpec应该是多个放肆term列表。子进度将被运转通过增添List到已存在的启航函数参数,也等于说,通过调用apply(M,
F, A++List),个中,{M,F,A}是概念在子典型的起步函数。

 

  即使已经存在2个钦赐id的子规范,ChildSpec被撤除,函数重临{error,already_present}
或 {error,{already_started,Child}},取决于对应的子过程是不是运转。

 

  假诺实进程运营函数重返{ok,Child} 或
{ok,Child,Info},子标准和过程号被增添到监督者,函数重返一样的值。

  借使实进度运转函数重临ignore,子标准被增添到监督者,进度号安装为undefined,函数再次来到{ok,undefined}。

  要是实进度运营哈数再次回到3个荒谬元组或3个张冠李戴值,
或它战败,子规范被废弃,函数重返{error,Error},当中Error是2个暗含关于错误和子标准音讯的term。

 

terminate_child(SupRef, Id) -> Result
Types:
  SupRef = sup_ref()
  Id = pid() | child_id()
  Result = ok | {error, Error}
    Error = not_found | simple_one_for_one

  告诉监督者SupRef终止给定的子进度。

 

  如果监督者不是simple_one_for_one,Id必须是子标准标记符。进度被终止,若是有,除非它是temporary子进程,子标准被监督者保存。子进度随后或者被监督者重启。子进程也大概显式的通过调用restart_child/2被重启。使用delete_child/二移除子规范。

 

  如若实进度是temporary,进度1终止,子标准就被去除。那意味delete_child/二没有意义,restart_child/二不或者用于这一个进度。

 

  假若监督者是simple_one_for_one,Id必须是子进度的pid(),若是钦命的进度活着,但不是给定监督者的子进度,函数将回到{error,not_found}。假使给定子标准标记,而不是pid(),函数将回来{error,simple_one_for_one}。

 

  要是成功,函数重回ok。要是未有点名Id的子标准,函数重回{error,not_found}。

 

  参考start_child/2了解SupRef的描述。

 

restart_child(SupRef, Id) -> Result
Types:
  SupRef = sup_ref()
  Id = child_id()
  Result = {ok, Child :: child()} | {ok, Child :: child(), Info :: term()} | {error, Error}
    Error = running | restarting | not_found | simple_one_for_one | term()

  告诉监督者SupRef重启一个子进程根据子标准标识符Id。子规范必须存在,对应子进度必须未有在运作。

 

  请留意temporary子进度,当子进程终止,子标准活动被剔除。随后,它无法重启这几个子进度。

 

  参看start_child/2了解SupRef的描述。

 

  若是实标准标志Id不设有,函数再次来到{error,not_found}。尽管实规范存在但相应进度早已运行,函数重回{error,running}。

 

  子进度运营函数再次来到{ok,Child} 或
{ok,Child,Info},进度号被增多到监督者,函数重回一样的值。

  子进度运行函数再次回到ignore,进度号依然设置为undefined,函数重临{ok,undefined}。

  子进度运维函数再次回到一个荒唐元组或三个谬误值,或它失利,函数重临{error,Error},个中,Error是三个分包错误消息的term。

 

which_children(SupRef) -> [{Id, Child, Type, Modules}]
Types:
  SupRef = sup_ref()
  Id = child_id() | undefined
  Child = child() | restarting
  Type = worker()
  Modules = modules()

  重回3个新创设列表,含有全部子标准和归属于监督者SupRef的子进度。

 

  请小心,在低内部存储器状态下,监督大批量子进度,调用该函数大概导致内部存款和储蓄器不足的分外。

 

  参考start_child/2了解SupRef的描述。

 

  对于每一种子标准/进度给出的音讯是:

  • Id –
    子规范中定义或在simple_one_for_one监督者情状下为undefined;
  • Child –
    对应子进度的进度号,函数将被重启为restarting或尚未该进程为undefined;
  • Type – 定义在子规范;
  • Modules – 定义在子标准。

 

count_children(SupRef) -> PropListOfCounts
Types:
  SupRef = sup_ref()
  PropListOfCounts = [Count]
  Count = {specs, ChildSpecCount :: integer() >= 0} | {active, ActiveProcessCount :: integer() >= 0}
       | {supervisors, ChildSupervisorCount :: integer() >= 0} | {workers, ChildWorkerCount :: integer() >= 0}

  重返一本天性列表,它包括监督者子标准的下列成分和被管制的经过的数码:

  •      specs –
    子进度活的或死的总的数量量;
  •      active –
    全部被监督者管理的激活的运转的子进程数量;
  •      supervisors –
    在专门的职业列表被标志为child_type =
    supervisor的全部子进程数量,不管仲进度是还是不是活着;
  •      workers –
    在正规列表被标志为child_type =
    worker的全数子进程数量,不管仲进度是还是不是活着;

 

check_childspecs(ChildSpecs) -> Result
Types:
  ChildSpecs = [child_spec()]
  Result = ok | {error, Error :: term()}

  该函数须要一个子正经列表作为参数,若是她们在语法上都毋庸置疑,再次来到ok,不然重回{error,Error}。

 

回调函数

Module:init(Args) -> Result
Types:
  Args = term()
  Result = {ok,{{RestartStrategy,MaxR,MaxT},[ChildSpec]}} | ignore
    RestartStrategy = strategy()
    MaxR = integer()>=0
    MaxT = integer()>0
    ChildSpec = child_spec()

  无论何时使用supervisor:start_link/贰,3监督者被运行,函数被二个新的历程调用寻觅重启计策、最大重启频率和子规范。

 

  Args是提须要运维函数的参数。

 

  RestartStrategy是重启攻略,马克斯翼虎 和
马克斯T定义监督者的最大重启频率。
[ChildSpec]是壹组有效地子规范,它定义哪些进程监督者应该运行和监察。参看上面关于监督规则的探究。

 

  请小心,当重启计谋为simple_one_for_one,子标准列表必须只包含二个子职业列表(ID被忽视)。在开始化时期,未有子进度随后被运营,不过全数子进度被设定使用supervisor:start_child/二来动态运转。

 

  函数也恐怕回到ignore。

 

  

  翻译有标题标地方,请大家指正。

  该函数被gen_server调用,当它妄想截止。它应该和Module:init/一相反,并做供给的清理。当它回到时,gen_server由于Reason终止。再次回到值被忽视。

  Reason是三个term,建议结束原因,State是gen_server的里边景况。

  Reason取决于gen_server终止的缘故。借使因为另三个回调函数已经回来三个悬停元组{stop,..},Reason将会有钦点的值在丰硕元组。若是是出于退步,Reason是荒唐原因。

  如果gen_server是监控树的一局地,并且被监察和控制者有序终止,该函数将被调用,使用Reason=shutdown,假诺运用以下情状:

  • gen_server已经设置为洗脱时限信号;
  • 再者,被定义在监察和控制者的子典型的闭馆战术是三个平头值,而不是brutal_kill。

  即使gen_server不是监察和控制者的壹有的,尽管接受来自父进度的’EXIT’音信,函数将被调用。Reason将和’EXIT’音信一点差距也未有于。

  否则,gen_server将立刻停下。

  注意,除了normal,shutdown,或{shutdown,Term}的别样原因,gen_server被设定终止由于二个错误,并且应用error_logger:format/二报告贰个谬误。

Module:code_change(OldVsn, State, Extra) -> {ok, NewState} | {error, Reason}
  Types:
    OldVsn = Vsn | {down, Vsn}
      Vsn = term()
    State = NewState = term()
    Extra = term()
    Reason = term()

  该函数被gen_server调用,当它在本子晋级/降级应该更新本身的中间景观,也正是说,当指令{update,Module,Change,…}在appup文件中被交给,当中Change={advanced,Extra}。参看OTP设计基准查看越来越多消息。

  在升高的情事下,OldVsn正是Vsn;在贬低的事态下,OldVsn正是{down,Vsn}。Vsn被回调模块Module的老版本的vsn属性定义。假诺未有如此的属性定义,版本就是BEAM文件的校验和。

  State是gen_server的当中意况。

  Extra来自晋级指令的{advanced,Extra}部分,被形容传递。

  若是成功,函数应该回到被更新的中间情形。

  要是函数重回{error,Reason},正在开展的升迁将会倒闭,并且回滚到老版本。

Module:format_status(Opt, [PDict, State]) -> Status
  Types:
    Opt = normal | terminate
    PDict = [{Key, Value}]
    State = term()
    Status = term()

  请小心,该回调可选,所以回调模块不需求导出它,那些回调模块提供一个私下认可完毕,该函数重回回调模块状态。

  该函数被gen_server进度调用:

  • sys:get_status/一,二被调用获取gen_server状态。那种情景,Opt被设置成normal。
  • gem_server极度终止,生成错误日志。那种情形,Opt被设置成terminate。

  该函数是立竿见影的,对于这么些境况定制gen_server的格式和显示。1个回调模块希望定制sys:get_status/壹,二的重临值,和它在悬停错误日志的情形显示,导出1个format_status/二实例,重临描述gen_server当前情状的term。

  PDict是gen_server的长河字典的近年来值。

  State是gen_server的中间景象。

  函数应该回到Status,定制当前事态的细节和gen_server的场所的term。在Status格式上尚未别的限制,不过对于sys:get_status/壹,二动静,对于Status提议的格式是[{data,
[{“State”,
Term}]}],其中,Term提供gen_server相关的细节。遵守这几个建议不是必须的,但是如此做将使回调模块的景观与sys:get_status/1,二的重返值1致。

  该函数的三个用法是再次回到紧密的轮换状态表示来幸免有过大的情景项打字与印刷在日记里。