劳力经过常常的落到实处利用gen

gen_server

概要

概要
  通用服务器行为
描述

  通用监督者行为

  行为模块落成服务器的客户端-服务器涉及。一个通用的服务器进度使用那一个模块将贯彻一组正式的接口功效,包罗追踪和错误报告效能。它也适合OTP进度监察和控制树。精晓更加多新闻参考OTP设计基准。

 

  gen_server假定全数特定部分位于一个回调模块,它导出的一组预订义的作用。行为函数和回调函数的涉嫌可以表达如下:

描述

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

  1个得以达成监督者的行事模块,3个监督被称为子进程的别样进度的长河。一个子经过能够是另1个监督者或工小编经过。工笔者经过常常的落到实处采取gen_event,gen_fsm和gen_server中的行为。监督者使用这些模块实现1组正式的接口函数和包含追踪和错误报告的功效。监督者被用来构建称为监察和控制树的分层进程组织,二个营造容错应用的很好的艺术。参考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将会告1段落。

  监督规则:

  gen_server管理种类音信,它们记录在sys。sys模块能够用来调治gen_server。

  监督者担当运维、甘休和监察和控制它的子进度。监督者的着力观念是,它应当保障它的子进度活着,要求时重启它们。

  请注意,gen_server并不自行地捕获退出非确定性信号,这么些必须精通地在回调模块运行。

 

  除非另作申明,假诺钦定的gen_server不存在或提交错误参数,该模块全体函数会战败。

  监督者的子进度被定义为子标准列表。当监督者被运行时,子进程依靠那个列表从左到右按梯次被运维。当监督者终止时,它首先按相反的开发银行顺序,从右到左终止它的子进度。

  假诺2个回调函数钦点”hibernate”而不是超时值,该gen_server进程会进来休眠。那说不定是卓有效用的,若是服务器推断闲置十分短1段时间。可是那几个功效应该小心使用,使用休眠意味着至少有多少个废物搜集(休眠又火速唤起),不是你想做的事体里面,每趟调用四个疲于奔命的服务器。

 

导出

  监督者能够有以下重启战略之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 –
假如实进程终止,应重新起动,惟有子进度遭到震慑。

  创制三个gen_server进度作为监察和控制树的一部分。函数应该平素或直接地被supervisor调用。它将保险gen_server在别的方面被链接到supervisor。

  one_for_all –
假诺实进度终止,应重新起动,全体其他子进度终止,那么全部的子进度被运行。

  gen_server进度调用Module:init/壹进行初叶化。为力保龄球联合汇合运行进程,start_link/三,四直至Module:init/1试行到位才具回到。

  rest_for_one –
若是实进度终止,应重新开动,前边的子进度,也正是说,按运维顺序,被甘休进程的后面包车型客车子进度被甘休。那么,终止进度和它背后全体的子进度被重启。

  如果ServerName={local,Name},gen_server使用register/二被登记为本土的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/2,它们表现得像global模块对应的函数。因而,{via,global,GlobalName}是3个一蹴而就地引用。

  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/2可被用来子进度。假使实标准标志符被使用,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。

  因为一个simple_one_for_one监督者能够有众多的子进度,它在同一时间将它们关闭。所以,它们被终止的逐一未有被定义。出于同样的原委,它恐怕有八个支付对于关闭战略。

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

 

  参看start_link/3,四了然参数和再次回到值的叙说。

  为防守监督者进入子进度终止和重启的极致循环,使用两个整数马克斯猎豹CS六 和
MaxT定义最大重启频率。假如在马克斯T秒重启超越马克斯Tiggo爆发,监督者终止全部子进度,随后停下它本身。

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是二个称呼,在内部被监督者用于标志子标准。

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

  

  提姆eout是贰个高于零的整数,它钦赐多少阿秒等待各个回复,原子infinity会Infiniti制期限的等候。暗中同意值是6000。如若在指定期期内并未有收受回复,函数会调用战败。固然调用者捕获战败并且延续运转,服务器仅仅晚些回复,它就要此外时候达到随后进入调用者的音讯队列。对此,调用者必须筹划那种处境,并且不保留任何杂质新闻,它们是八个要素元组作为第1个成分。

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

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

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

  调用大概会因为三种原因退步,蕴涵超时和在调用前和调用进度中gen_server死掉。

 

  在调用时期当连接到客户端,如果服务器死掉,有时会损耗退出消息,这几个过时的行为早就在OTP
Evoque1贰B/Erlang 五.陆中移除。

  
假若实进程因为一些缘故不可能运营,运营函数也足以重回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举行共同调用,通过第1次发送请求到各类节点,然后等待恢复生机。这个gen_server进度将会调用Module:handle_call/三管理请求。

  
如若出现错误,函数也说不定回到错误元组{error,Error}。

  函数重临元组{Replies,BadNodes},当中,Replies是{Node,Reply}的列表,BadNodes是不设有节点的列表,或gen_server
Name不设有或从不回复。

 

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

  
请注意,start_link函数,分裂的表现模块满意上述的要求。

  Name是每个gen_server被地面注册的名目。

 

  Request是2个大4term,它看做内部的参数传递给Module:handle_call/3。

  
Restart定义何时甘休的子进度应该被重启。多个permanent子进度应该总是被重启,一个temporary子进度未有被重启(即便当监督者的重启计策是rest_for_one或one_for_all和兄弟进程的挂掉导致temporary进程被停止),和二个transient子进度应该被重启仅当它足够终止,约等于说,除过normal,shutdown或{shutdown,Term}的别样退出原因。

  Timeout是三个高于零的整数,它内定多少阿秒等待各类回复,原子infinity会Infiniti时的等候。暗中认可值是infinity。假如在指定时间内节点未有接过回复,该节点被参与到BadNodes。
当在节点Node来自gen_server回复Reply达到,{Node,Reply}被投入到Replies。Reply被定义在Module:handle_call/三的回来值里。

 

  为制止随后的应对(在逾期从此)污染调用者的新闻队列,一当中间人经过被用来坚实际的调用。当它们达到二个停下的历程,迟到的回复将不会被封存。

  
Shutdown定义子进度应该什么被截止。brutal_kill意味着子进度将被白白结束使用exit(Child,kill)。贰个整数超时值意味着监督者将告诉子进程经过调用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/2处理请求。

  
倘诺实进度是另三个监督者,Shutdown应该被设置成infinity,给子树丰盛的时日关闭。假使实进度是劳重力,它也被允许设置成infinity。

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

 

  Request是贰个大四term,它看做内部的参数字传送递给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/2,3,四,领悟参数描述。

 

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

  
Type钦赐子进度是监督者照旧工小编。

  当回复未有概念在Module:handle_call/三的回来值里,该函数可以被gen_server用来显式地发送过来给三个调用
call/二,3 或 multi_call/二,3,四的客户端。

 

  Client必须是提必要回调函数的From参数。Reply是三个率性term,它将作为call/贰,3或 multi_call/二,3,4的再次来到值被苏醒到客户端。

  
Modules被版本管理程序使用,在代码替换时期用于分明哪些进度使用什么模块。作为一个经历法则,Modules应该一个成分列表[Module],在那之中,Module是回调模块,假如子进程是三个supervisor,
gen_server 或
gen_fsm。假如实进度是3个包涵回调模块集结的风云管理器(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若是未有经过号存在。

  使三个已存在的进度进入二个gen_server。不回去,反而这一个调用进度将进入gen_server的吸收循环,并变为二个gen_server进度。那个进程必须使用proc_lib的启航函数被运转。用户为该进度的其余先河化负担,包蕴为它注册二个名字。

 

  这么些函数至极有用,当须要二个更为复杂的早先化进程,而不是gen_server行为提供的。

数据类型

  Module,Option
和ServerName与调用gen_server:start[_link]/3,4兼有一样的意思。可是,倘诺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和提姆eout与Module:init/一的重回值有着同样的意义。回调模块Module也不供给导出二个init/壹函数。

 

  战败:如若调用过程未被一个proc_lib函数运行,恐怕只要它未依据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个监督者进度作为监察和控制树的一部分,在其余地方,函数将确定保障监督者链接到调用者进度(它的监督者)。

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

 

  Args是提需要运行函数的参数。

  被创建的监督者进度调用Module:init/一找寻重启计谋、最大运维频率和子进程。为保障联合运转进度,start_link/2,3不会再次回到直到Module:init/1已经回到且全数子进程已被运营。

  假设早先化成功,函数应该回到{ok,State}, {ok,State,Timeout} 或
{ok,State,hibernate},个中,State是gen_server的当中意况。

 

  假诺3个平头超时值被提供,多少个超时将发生,除非在Timeout皮秒内收取一个请求或消息。叁个逾期被timeout原子标识,它应当被handle_info/叁回调函数管理。infinity能够被用来无有效期地等候,那是暗许值。

  借使SupName={local,Name},supervisor使用register/2被登记为当地的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被钦定而不是多个超时值,进度将进入休眠当等待下一条新闻抵达时(调用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是2个元组{Pid,Tag},当中,Pid是客户端的经过号,Tag是八个唯1标识。

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

  State是gen_server的个中景观。

 

  若是函数再次回到{reply,Reply,NewState}, {reply,Reply,NewState,Timeout}
或 {reply,Reply,NewState,hibernate},Reply将被还原给From作为call/二,3 或
multi_call/二,叁,四的重回值。然后gen_server继续推行,恐怕更新内部景观NewState。参看Module:init/一领悟Timeout和hibernate的叙述。

  借使监督者和它的子进度被成功创办,(也等于说,若是全体子进度运维函数重临{ok,Child},
{ok,Child,Info}, 或
ignore)函数重回{ok,Pid},个中Pid是监督者的进程号。假若已存在钦定SupName的进度,函数重临{error,{already_started,Pid}},当中,Pid是万分进度的进度号。

  若是函数重临{noreply,NewState}, {noreply,NewState,Timeout} 或
{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}是概念在子标准的启航函数。

 

  即使已经存在二个点名id的子规范,ChildSpec被撤除,函数重临{error,already_present}
或 {error,{already_started,Child}},取决于对应的子进度是还是不是运转。

 

  如果实进度运行函数重返{ok,Child} 或
{ok,Child,Info},子标准和经过号被增多到监督者,函数重返一样的值。

  假如实进度运维函数再次回到ignore,子标准被加多到监督者,进度号安装为undefined,函数重回{ok,undefined}。

  若是实进程运行哈数重回2个荒谬元组或3个荒谬值,
或它失利,子标准被抛弃,函数重回{error,Error},个中Error是贰个饱含关于错误和子标准音讯的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/2不能用于那些进度。

 

  若是监督者是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}。

  子进度运维函数重临三个错误元组或2个不当班值日,或它战败,函数重临{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()

  重回二个新制造列表,含有全部子规范和归属于监督者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/贰,三监督者被运行,函数被贰个新的经过调用寻觅重启战术、最大重启频率和子标准。

 

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

 

  RestartStrategy是重启计策,马克斯昂Cora 和
马克斯T定义监督者的最大重启频率。
[ChildSpec]是一组有效地子规范,它定义哪些进程监督者应该运转和监理。参看下边关于监督规则的座谈。

 

  请留心,当重启攻略为simple_one_for_one,子标准列表必须只含有二个子正规列表(ID被忽视)。在起先化期间,未有子进程随后被运行,不过全体子进程被设定使用supervisor:start_child/二来动态运营。

 

  函数也说不定回到ignore。

 

  

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

  该函数被gen_server调用,当它妄图截止。它应有和Module:init/一相反,并做须要的清理。当它回到时,gen_server由于Reason终止。重回值被忽略。

  Reason是3个term,建议截至原因,State是gen_server的个中景况。

  Reason取决于gen_server终止的原委。借使因为另3个回调函数已经回来八个平息元组{stop,..},Reason将会有钦定的值在老大元组。倘诺是出于战败,Reason是一无所长原因。

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

  • gen_server已经设置为洗脱非确定性信号;
  • 与此同时,被定义在监察和控制者的子标准的破产战略是3个平头值,而不是brutal_kill。

  即使gen_server不是监察和控制者的1部分,要是收到来自父进程的’EXIT’音讯,函数将被调用。Reason将和’EXIT’消息未有差距于。

  否则,gen_server将立时终止。

  注意,除了normal,shutdown,或{shutdown,Term}的此外原因,gen_server被设定终止由于3个荒唐,并且利用error_logger:format/2报告二个张冠李戴。

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的格式和表现。贰个回调模块希望定制sys:get_status/一,贰的重临值,和它在悬停错误日志的处境展现,导出贰个format_status/2实例,重回描述gen_server当前事态的term。

  PDict是gen_server的历程字典的脚下值。

  State是gen_server的当中境况。

  函数应该回到Status,定制当前景况的细节和gen_server的状态的term。在Status格式上从来不别的限制,但是对于sys:get_status/1,二景色,对于Status提出的格式是[{data,
[{“State”,
Term}]}],其中,Term提供gen_server相关的底细。听从那几个提出不是必须的,不过这么做将使回调模块的情事与sys:get_status/1,二的重临值1致。

  该函数的二个用法是重返紧密的轮换状态表示来幸免有过大的气象项打字与印刷在日记里。