劳力经过平时的兑现选择gen

gen_server

概要

概要
  通用服务器行为
描述

  通用监督者行为

  行为模块达成服务器的客户端-服务器涉及。三个通用的服务器进程使用这么些模块将落到实处一组正式的接口作用,包含追踪和错误报告成效。它也合乎OTP进程监察和控制树。领会越多音讯参照他事他说加以考察OTP设计条件。

 

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

描述

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

  1个落到实处监督者的表现模块,一个监察被称为子进度的此外进度的进程。一个子进度能够是另3个监督者或工作者经过。工小编经过平时的贯彻利用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

  监督者设定哪些子进度被监督的定义,位于导出一组预约义函数的回调模块。

  -               —–> Module:handle_info/2

 

  -               —–> Module:terminate/2

  除非另作注解,若是钦赐的supervisor不设有或提交错误参数,该模块全数函数会失利。

  -               —–> Module:code_change/3

 

  借使1个回调函数败北或回到三个张冠李戴的值,gen_server将会结束。

  监督规则:

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

  监督者担任运维、结束和监察它的子进度。监督者的主干思考是,它应该有限帮助它的子进度活着,须求时重启它们。

  请注意,gen_server并不活动地捕获退出确定性信号,这些必须旗帜分明地在回调模块运行。

 

  除非另作表明,假若钦点的gen_server不存在或提交错误参数,该模块全部函数会失利。

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

  假设3个回调函数内定”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 –
借使实进度终止,应重新开动,唯有子进程面前碰着震慑。

  创造1个gen_server进程作为监察和控制树的一有的。函数应该一向或直接地被supervisor调用。它将保障gen_server在其余方面被链接到supervisor。

  one_for_all –
假使实进程终止,应重新起动,全部别的子进度终止,那么富有的子进度被运行。

  gen_server进度调用Module:init/一举办初叶化。为确定保证龄球联合会见运维进度,start_link/叁,4截至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}是一个得力地引用。

  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监督者下,通过给定子进度的进程号作为第1个参数,函数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/三,四打探参数和重返值的叙说。

  为防备监督者进入子进度终止和重启的非常循环,使用五个整数Max悍马H2 和
马克斯T定义最大重启频率。借使在MaxT秒重启超越马克斯奥迪Q5发生,监督者终止全数子进度,随后停下它自身。

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/3管理请求。

  那是子规范的类型定义:

  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是二个任性term,它看做内部的参数传递给Module:handle_call/3。

  

  Timeout是三个大于零的整数,它钦命多少纳秒等待各个回复,原子infinity会Infiniti制时间的等待。暗许值是伍仟。如若在指按期期内并未有接收回复,函数会调用退步。若是调用者捕获战败并且再三再四运营,服务器仅仅晚些回复,它将要其余时候到达随后进入调用者的音讯队列。对此,调用者必须企图这种情景,并且不保留任何杂质新闻,它们是三个元素元组作为第二个成分。

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

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

  
运维函数必须成立和链接到子进程,应该回到{ok,Child}或{ok,Child,Info},个中Child是子进程的经过号,Info是大肆term被监督者忽略。

  调用可能会因为两种原因战败,包蕴超时和在调用前和调用过程中gen_server死掉。

 

  在调用时期当连接到客户端,如若服务器死掉,有的时候会损耗退出音信,这几个过时的行为已经在OTP
QX561二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进行协同调用,通过第2次发送请求到各类节点,然后等待回复。那一个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是1个任性term,它看成内部的参数字传送递给Module:handle_call/3。

  
Restart定义哪天截止的子进程应该被重启。3个permanent子进度应该总是被重启,一个temporary子进度未有被重启(固然当监督者的重启攻略是rest_for_one或one_for_all和兄弟进度的挂掉导致temporary进程被终止),和二个transient子进度应该被重启仅当它不行终止,也便是说,除过normal,shutdown或{shutdown,Term}的任何退出原因。

  提姆eout是三个高于零的整数,它钦点多少皮秒等待每种回复,原子infinity会无限时的等待。暗中同意值是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()

 

  发送3个异步请求到引用名ServerRef的gen_server,然后随即赶回ok,假使目的节点或gen_server不存在,忽略新闻。gen_server将调用Module:handle_cast/二管理请求。

  
如若实进度是另3个监督者,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()

 

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

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

  参看 multi_call/贰,三,四,了然参数描述。

 

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

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

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

 

  Client必须是提须要回调函数的From参数。Reply是二个放肆term,它将用作call/二,叁或 multi_call/贰,三,4的重回值被恢复到客户端。

  
Modules被版本管理程序使用,在代码替换时期用于鲜明什么进程使用什么模块。作为七个经历法则,Modules应该贰个要素列表[Module],在那之中,Module是回调模块,如若子过程是1个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若是未有经过号存在。

  使二个已存在的进程进入1个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/一的重回值有着同样的意思。回调模块Module也不须求导出一个init/1函数。

 

  败北:假使调用进度未被3个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()

  成立三个监督者进度作为监察和控制树的壹有的,在其他方面,函数将保险监督者链接到调用者进度(它的监督者)。

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

 

  Args是提供给运营函数的参数。

  被创建的监督者进度调用Module:init/1搜索重启战略、最大运行频率和子进度。为力保同步运转进度,start_link/2,叁不会回去直到Module:init/一已经重回且全部子进程已被运行。

  假诺开头化成功,函数应该回到{ok,State}, {ok,State,Timeout} 或
{ok,State,hibernate},个中,State是gen_server的在那之中情况。

 

  假设三个平头超时值被提供,三个过期将时有爆发,除非在提姆eout皮秒内接收几个伸手或音信。叁个超时被timeout原子标记,它应该被handle_info/三遍调函数管理。infinity能够被用来Infiniti时地等候,那是默许值。

  假如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/一 和
send/2,它们表现得像global模块对应的函数。因而,{via,global,Name}是2个管用地引用。

  即使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是三个元组{Pid,Tag},个中,Pid是客户端的历程号,Tag是三个唯1标识。

  Args是三个大4term,作为参数字传送递给Module:init/1。

  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个错误元组或2个错误值,监督者首先将以原因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调用,当超时发生或收受到其余新闻而不是联合或异步请求(或然系统音讯)。

  动态扩充贰个子正式到监督者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}。

  若是实进度运行哈数重返多个谬误元组或贰个荒谬值,
或它失利,子标准被撇下,函数再次来到{error,Error},在这之中Error是3个富含关于错误和子标准音讯的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,进度一终止,子标准就被删除。这象征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}。

  子进程运转函数重临1个荒谬元组或二个荒谬值,或它失利,函数重回{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}

  再次来到2个性质列表,它包蕴监督者子标准的下列成分和被管制的历程的数额:

  •      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是重启战术,马克斯Tiguan 和
马克斯T定义监督者的最大重启频率。
[ChildSpec]是一组有效地子标准,它定义哪些进程监督者应该运行和监察。参看下面境海关于监督规则的探究。

 

  请小心,当重启战略为simple_one_for_one,子标准列表必须只含有3个子规范列表(ID被忽视)。在起先化时期,未有子进度随后被运维,不过全部子进程被设定使用supervisor:start_child/二来动态运营。

 

  函数也恐怕回到ignore。

 

  

  翻译有标题标地点,请我们指正。

  该函数被gen_server调用,当它盘算结束。它应有和Module:init/1相反,并做供给的清理。当它回到时,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/二报告1个张冠李戴。

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/1,2被调用获取gen_server状态。这种情状,Opt被设置成normal。
  • gem_server极度终止,生成错误日志。这种情景,Opt被安装成terminate。

  该函数是行得通的,对于这么些情状定制gen_server的格式和表现。一个回调模块希望定制sys:get_status/1,二的重返值,和它在终止错误日志的动静呈现,导出1个format_status/二实例,再次回到描述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致。

  该函数的二个用法是回到紧密的更迭状态表示来防止有过大的状态项打字与印刷在日记里。

相关文章