gen_server
gen_server
1、gen_server起步
现在我们来到了最细节的部分。下面是写gen_server回调模块的3个要点，很简单。
- 确定一个回调模块的名称。
- 写接口函数。
- 在回调模块中写需要的6个回调函数。
这确实很简单，无须思考——只管照着做就行了。
1.1、第一步:确定回调模块的名称
下面要做一个非常简单的支付系统，我们把这个模块命名为my_bank。
1.2、第二步:写接口函数
我们会定义下面5个接口函数，它们都在my_bank模块之中。
- start()打开银行。(启动服务器)
- stop()关闭银行。
- new_account(Who)开一个新账户。
- eposit(Who，Amount)存钱。
- withdraw(who，Amount)取钱，当然，这里需要判断余额是否足够。
每一个函数都意味着对gen_server中的例程的一次调用，如下:
start() -> gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
stop() -> gen_server:call(?MODULE, stop).
new_account(Who) -> gen_server:call(?MODULE, {new, Who}).
deposit(Who, Amount) -> gen_server:call(?MODULE, {add, Who, Amount}).
withdraw(Who, Amount) -> gen_server:call(?MODULE, {remove, Who, Amount}).
gen_server:start_link({loca1，Name}，Mod, , )会启动一个本地服务器。?MODULE宏展开的时候会对应模块的名称，也就是这里的my_bank。Mod是回调模块的名称。现在我们暂时忽略gen_server:start的其他参数。
gen_server:ca11 (?MODULE，Term)用来发起对服务器的远程调用。
1.3、第三步:编写回调函数
回调模块必须开放6个回调函数:init/1、handle_ca11/3、handle_cast/2、 handle_info/2、terminate/2和code_change/3。
为了更加省事，我们可以用模板来写gen_server程序，这是最简单的模板;
gen_server_template.mini
-module().
%% gen.server .minitemp1ate
-behaviour(gen_server).
-export([startlink/0]).
%% gen_server ca11backs
-export([init/1，handle_ca11/3，handle_cast/2， handle_info/2,
terminate/2,code__change/3]).
start_link() -> gen_server:start_link({loca1，?SERVER}，?MODULE，[]，[]).
init([]) -> {ok，State}.
handle_ca11( Request，_From，state) -> {rep1y，Reply，State}.handle_cast(Msg，State) -> {noreply，State}.
handle_info(_Info，State) -> {noreply，State} .terminate(_Reason，_state) -> ok.
code_change(_O1dVsn，State，Extra) -> {ok，State}.
填充这个模板，不断编辑，最终得到的代码会是下面这样:
my_bank.erl
init([]) -> {ok, ets:new(?MODULE,[])}.
handle_call({new,Who}, _From, Tab) ->
Reply = case ets:lookup(Tab, Who) of
[] -> ets:insert(Tab, {Who,0}),
{welcome, Who};
[_] -> {Who, you_already_are_a_customer}
end,
{reply, Reply, Tab};
handle_call({add,Who,X}, _From, Tab) ->
Reply = case ets:lookup(Tab, Who) of
[] -> not_a_customer;
[{Who,Balance}] ->
NewBalance = Balance + X,
ets:insert(Tab, {Who, NewBalance}),
{thanks, Who, your_balance_is, NewBalance}
end,
{reply, Reply, Tab};
handle_call({remove,Who, X}, _From, Tab) ->
Reply = case ets:lookup(Tab, Who) of
[] -> not_a_customer;
[{Who,Balance}] when X =< Balance ->
NewBalance = Balance - X,
ets:insert(Tab, {Who, NewBalance}),
{thanks, Who, your_balance_is, NewBalance};
[{Who,Balance}] ->
{sorry,Who,you_only_have,Balance,in_the_bank}
end,
{reply, Reply, Tab};
handle_call(stop, _From, Tab) ->
{stop, normal, stopped, Tab}.
handle_cast(_Msg, State) -> {noreply, State}.
handle_info(_Info, State) -> {noreply, State}.
terminate(_Reason, _State) -> ok.
code_change(_OldVsn, State, _Extra) -> {ok, State}.
完整程序：
-module(my_bank).
-behaviour(gen_server).
-export([start/0]).
%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
-compile(export_all).
-define(SERVER, ?MODULE).
start() -> gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
stop() -> gen_server:call(?MODULE, stop).
new_account(Who) -> gen_server:call(?MODULE, {new, Who}).
deposit(Who, Amount) -> gen_server:call(?MODULE, {add, Who, Amount}).
withdraw(Who, Amount) -> gen_server:call(?MODULE, {remove, Who, Amount}).
init([]) -> {ok, ets:new(?MODULE,[])}.
handle_call({new,Who}, _From, Tab) ->
Reply = case ets:lookup(Tab, Who) of
[] -> ets:insert(Tab, {Who,0}),
{welcome, Who};
[_] -> {Who, you_already_are_a_customer}
end,
{reply, Reply, Tab};
handle_call({add,Who,X}, _From, Tab) ->
Reply = case ets:lookup(Tab, Who) of
[] -> not_a_customer;
[{Who,Balance}] ->
NewBalance = Balance + X,
ets:insert(Tab, {Who, NewBalance}),
{thanks, Who, your_balance_is, NewBalance}
end,
{reply, Reply, Tab};
handle_call({remove,Who, X}, _From, Tab) ->
Reply = case ets:lookup(Tab, Who) of
[] -> not_a_customer;
[{Who,Balance}] when X =< Balance ->
NewBalance = Balance - X,
ets:insert(Tab, {Who, NewBalance}),
{thanks, Who, your_balance_is, NewBalance};
[{Who,Balance}] ->
{sorry,Who,you_only_have,Balance,in_the_bank}
end,
{reply, Reply, Tab};
handle_call(stop, _From, Tab) ->
{stop, normal, stopped, Tab}.
handle_cast(_Msg, State) -> {noreply, State}.
handle_info(_Info, State) -> {noreply, State}.
terminate(_Reason, _State) -> ok.
code_change(_OldVsn, State, _Extra) -> {ok, State}.
运行测试
2> my_bank:start().
{ok,<0.81.0>}
3> my_bank:deposit("joe",10).
not_a_customer
4> my_bank:new_account("joe").
{welcome,"joe"}
5> my_bank:deposit("joe",10).
{thanks,"joe",your_balance_is,10}
6>
2、gen_server回调的结构
2.1、启动服务器时发生了什么
我们自己写的一个gen_server回调模块，，一般会有一个start接口函数开启服务，这个start()函数由我们自己写的，start()函数里面其实是调用gen_server:start_link()函数。gen_server:start_link(Name，Mod，InitArgs，Opts)调用负责启动所有这一切。它创建了一个名为Name的通用服务器程序，它的回调模块是Mod，0pts则控制了这个通用服务器程序的行为。在这里我们可以指定日志信息、调试函数等。然后就是调用Mod:init(InitArgs)来启动服务器程序。
%% ---------------------------------------------
%% Function: init(Args) -> {ok,State} |
%% {ok,State,Timeout}|
%% ignore |
%% {stop,Reason} |
%% Description: Initiates the server
init([]) ->
{ok,#state{}}
通常情况下，我们返回的是{ok，State}。如果想知道其他参数的含义，可以查阅文档中关于gen_server的部分。
返回值是{ok，State}，这意味着已经成功启动，服务器的初始状态是State。
2.2、调用服务器程序时发生了什么
为了调用服务器程序，客户端程序的接口会调用函数gen_server:call(Name，Request)。这会导致调用回调模块中的handle_ca11/3函数。
%% ---------------------------------------------
%% Function:
%% handle_call(Request,From,State) -> {reply,Reply,State} |
%% {reply,Reply,State,TimeOut}|
%% {noreply,State} |
%% {noreply,State,TimeOut} |
%% {stop,Reason,Replu,State} |
%% {stop,Reason,State} |
%% Description: Handling call messages
handle_call(_Request,_From,State) ->
Reply = ok,
{reply,Reply,State}
如果一切正常的话，我们返回{replay，Reply，NewState}。这个时候，Reply会作为gen_server:ca11的返回值提交给客户端，而NewState是服务器的新状态。
其他的返回值包括{noreply,…}和{stop,…}，它们用得相对较少。noreply会使得服务器继续运行，但客户端会等待回应，回调程序要从服务框架接管向其他进程返回数据的职责。而stop则会导致服务器程序终止运行。
2.3、调用和通知
我们已经看到了在gen_server:call和handle_call之间的交互动作。它们主要用来实现远程调用（RPC）。而gen_server:cast(Name，Name)则实现了通知(cast)，就是一个无返回值程过程调用（RPC)的调用(实际上，也就是发送一个消息，但传统上将这种情况叫做通知，用来和远程调用区别开来）。
相应的回调函数是handle_cast，在模板中的入口是这样的:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LyCubEks-1625996866533)(EF4A0FD447B04FF49DDCF76E3C609AC4)]
处理程序通常只返回{noreply，NewState}，这会改变服务器的状态;它也可以返回{stop,… .}，这会终止服务器。
2.4、发送给服务器的原生消息
回调函数handle_info(Info，State)用来处理发给服务器的原生消息。那么，到底什么样的消息才是原生消息呢?如果服务器和其他的进程建立了连接，并且正在捕捉退出事件，那么它有可能会突然收到意外的{'EXIT’，Pid,what}这样的消息。又或者，系统中的其他进程获得了通用服务器程序的PID，那么它可能会给服务器发送消息。诸如此类的消息最终都会作为Info的值传给回调程序。
handle_info在模板中的入口是这样的:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rD97NXXf-1625996866542)(2EC87A6865DC4337A4C914D3BB7BC71C)]
2.5、HastalaVista,Baby(服务器的终止)
很多原因会导致服务器终止。比如，在handle_ Somethi ng函数中返回一个{stop，Reason,
NewState}，或者直接终止服务器，返回-一个{‘EXIT’, reason}。所有这些情况，无论是怎么引
起的，无- -例外，都会调用回调模块的terminate(Reason，NewState) 函数。
模板是这样的:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jIGdhPUC-1625996866549)(29DE4B951CA846D49118BEC1BFC79DA1)]
因为我们要终止了，所以这个代码没有必要再返回一个新的状态了。那么，要如何处理参数
中的这个State呢?其实还是有很多事情可以做的。主要取决于你的应用程序，比如，可以把这
个State写到磁盘，以消息形式发给另一个进程，或者直接丢掉。如果将来某个时候你还要再次
启动这个服务器，可以用terminate/2来触发“I’ll be back”函数。
2.6、热代码替换
你可以在运行中动态地改变服务器的状态。版本管理子系统会在系统对软件进行升级时调用
这个回调函数。
模板是这样的:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mw5GMqdg-1625996866560)(18F30959DE04429CBE146138B5AEC1CD)]
3、gen_server详解
https://www.cnblogs.com/hzy1987/p/5441807.html
3.1、启动服务器
用来启动服务器的有start/3,start/4,start_link/3,start_link/4这四个函数。 使用这些start函数之后，就会产生一个新的进程，也就是一个gen_server服务器。这些 start函数的正常情况下返回值是{ok,Pid}，Pid就是这个新进程的进程号。 start_link和start的区别在于是否跟父进程建立链接，换种说法是，新启动的进程死掉后，会不会通知启动他的进程（父进程）。
函数
start(Module, Args, Options) -> Result
start(ServerName, Module, Args, Options) -> Result
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} | {hibernate_after,HibernateAfterTimeout} | {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()
start函数可以四个参数(ServerName, Module, Args, Options)：
- 第一个参数ServerName是服务名，值为 {local,Name} | {global,GlobalName}
| {via,Module,ViaName}， 是可以省掉的。具有相同服务名的模块在一个节点中只能启动一次，重复启动会报错，为 {error, {already_started, Pid}}。具有服务名的服务进程可以使用服务名来调用， 没有服务名的只能通过进程号pid来调用了。通常有名字的服务进程会使用模块名做为 服务名，即上面模板中定义的宏-define(SERVER, ?MODULE)，然后在需要使用服务名的 地方填入?SERVER. - 第二个参数Module是模块名，一般而言API和回调函数是写在同一个文件里的，所以就用 ?MODULE，表示本模块的模块名。
- 第三个参数Args是回调函数init/1的参数，会原封不动地传给init/1。
- 第四个参数Options是一些选项，可以设置debug、超时等东西。
start对应的回调函数是init/1，一般来说是进行服务器启动后的一些初始化的工作， 并生成初始的状态State，正常返回是{ok, State}。这个State是贯穿整个服务器， 并把所有六个回调函数联系起来的纽带。它的值最初由init/1生成， 此后可以由三个handle函数修改，每次修改后又要放回返回值中， 供下一个被调用的handle函数使用。 如果init/1返回ignore或{stop, Reason}，则会中止服务器的启动。
有一点细节要注意的是，API函数和回调函数虽然习惯上是写在同一个文件中，但执行函数 的进程却通常是不一样的。在上面的模板中，start_link/0中使用self()的话，显示的是调用者的进程号，而在init/1中使用self()的话，显示的是服务器的进程号。
Module:init(Args) -> Result
Types
Args = term()
Result = {ok,State} | {ok,State,Timeout} | {ok,State,hibernate}
| {ok,State,{continue,Continue}} | {stop,Reason} | ignore
State = term()
Timeout = int()>=0 | infinity
Reason = term()
源码
gen_server.erl
start(Name, Mod, Args, Options) ->
gen:start(?MODULE, nolink, Name, Mod, Args, Options).
%% Name-服务名，Mod- 回调模块，Args-参数，Options-选项
start_link(Name, Mod, Args, Options) ->
gen:start(?MODULE, link, Name, Mod, Args, Options).
这里start和start_link的区别在于调用gen:start函数时，LinkP参数为nolink还是link，后面以start_link进行讲解
gen.erl
%%GenMod-模块gen_server,LinkP-link,Name-服务名，Args-参数，Options-选项
start(GenMod, LinkP, Name, Mod, Args, Options) ->
case where(Name) of
undefined -> %%如果还没有服务名
do_spawn(GenMod, LinkP, Name, Mod, Args, Options);
Pid -> %%如果服务名已存在，返回错误
{error, {already_started, Pid}}
end.
%%start_link
%%GenMod-模块gen_server,LinkP-link,Name-服务名，Args-参数，Options-选项
do_spawn(GenMod, link, Name, Mod, Args, Options) ->
Time = timeout(Options),
proc_lib:start_link(?MODULE, init_it,
[GenMod, self(), self(), Name, Mod, Args,Options],%%[GenMod-gen_server,self(),self(),Name,Mod-回调模块，Args,Options]
Time,
spawn_opts(Options));
%%start
do_spawn(GenMod, _, Name, Mod, Args, Options) ->
Time = timeout(Options),
proc_lib:start(?MODULE, init_it,
[GenMod, self(), self, Name, Mod, Args, Options],
Time,
spawn_opts(Options)).
可以看出，start_link和start的区别在于调用proc_lib:start时，封装的参数A中，第三个参数不同，start_link为self()当前进程自己,start为self。
proc_lib.erl
%%M-模块gen，F-init_it,A-[GenMod, self(), self(), Name, Mod, Args, Options],Time-超时时间，SpawnOpts-spawn_opts(Options)
start_link(M,F,A,Timeout,SpawnOpts) when is_atom(M), is_atom(F), is_list(A) ->
?VERIFY_NO_MONITOR_OPT(M, F, A, Timeout, SpawnOpts),
sync_start_link(?MODULE:spawn_opt(M, F, A, [link|SpawnOpts]), Timeout).
sync_start_link(Pid, Timeout) ->
receive
{ack, Pid, Return} ->
Return;
{'EXIT', Pid, Reason} ->
{error, Reason}
after Timeout ->
kill_flush(Pid),
{error, timeout}
end.
erlang.erl
%%_Module-gen模块，_Function-init_it,_Args-[GenMod, self(), self(), Name, Mod, Args, Options],Time-超时时间
spawn_opt(_Module, _Function, _Args, _Options) ->
erlang:nif_error(undefined).
spawn_opt/4与spawn/3一样工作，只是在创建进程时指定了一个额外的选项列表。如果指定了选项link（start_link）,连接到父进程；指定了选项monitor(start)，则监视新创建的进程，并返回监视器的pid和引用；。
spawn/3就是新建进程，其入口点为Module:Fun，也就是gen:init_it(),参数为[GenMod-gen_server,self(),self(),Name,Mod-回调模块，Args,Options]。这时已经启动了一个新的并发进程，也就是gen_sever服务器，来执行后面的代码。
让我们看gen:init_it()函数
gen.erl
%%[GenMod-gen_server,self(),self(),Name-服务名称,Mod-回调模块，Args-参数,Options]
init_it(GenMod, Starter, Parent, Name, Mod, Args, Options) ->
case register_name(Name) of
true ->
init_it2(GenMod, Starter, Parent, Name, Mod, Args, Options);
{false, Pid} ->
proc_lib:init_ack(Starter, {error, {already_started, Pid}})
end.
首先调用register_name(Name),将进程自己self()注册一个名为Name的原子
register_name({local, Name} = LN) ->
try register(Name, self()) of
true -> true
catch
error:_ ->
{false, where(LN)}
end;
register_name({global, Name} = GN) ->
case global:register_name(Name, self()) of
yes -> true;
no -> {false, where(GN)}
end;
register_name({via, Module, Name} = GN) ->
case Module:register_name(Name, self()) of
yes ->
true;
no ->
{false, where(GN)}
end.
注册成功，执行init_it2/6函数
init_it2(GenMod, Starter, Parent, Name, Mod, Args, Options) ->
GenMod:init_it(Starter, Parent, Name, Mod, Args, Options).
init_it2函数调用gen_server:init_it/6函数，这里注意调用start_link和start第2个参数Parent的不同，start_link的话Parent是调用start_link当前进程自己，而start为self。
gen_server.erl
init_it(Starter, self, Name, Mod, Args, Options) ->
init_it(Starter, self(), Name, Mod, Args, Options);
init_it(Starter, Parent, Name0, Mod, Args, Options) ->
Name = gen:name(Name0),
Debug = gen:debug_options(Name, Options),
HibernateAfterTimeout = gen:hibernate_after(Options),
case init_it(Mod, Args) of
{ok, {ok, State}} ->
proc_lib:init_ack(Starter, {ok, self()}),
loop(Parent, Name, State, Mod, infinity, HibernateAfterTimeout, Debug);
{ok, {ok, State, Timeout}} ->
proc_lib:init_ack(Starter, {ok, self()}),
loop(Parent, Name, State, Mod, Timeout, HibernateAfterTimeout, Debug);
{ok, {stop, Reason}} ->
%% For consistency, we must make sure that the
%% registered name (if any) is unregistered before
%% the parent process is notified about the failure.
%% (Otherwise, the parent process could get
%% an 'already_started' error if it immediately
%% tried starting the process again.)
gen:unregister_name(Name0),
proc_lib:init_ack(Starter, {error, Reason}),
exit(Reason);
{ok, ignore} ->
gen:unregister_name(Name0),
proc_lib:init_ack(Starter, ignore),
exit(normal);
{ok, Else} ->
Error = {bad_return_value, Else},
proc_lib:init_ack(Starter, {error, Error}),
exit(Error);
{'EXIT', Class, Reason, Stacktrace} ->
gen:unregister_name(Name0),
proc_lib:init_ack(Starter, {error, terminate_reason(Class, Reason, Stacktrace)}),
erlang:raise(Class, Reason, Stacktrace)
end.
case init_it(Mod, Args)调用init_it/2函数，参数为（Mod-回调模块，Args-init参数)。然后调用Mod:init/1，也就是回调模块的init()函数。
init_it(Mod, Args) ->
try
{ok, Mod:init(Args)}
catch
throw:R -> {ok, R};
Class:R:S -> {'EXIT', Class, R, S}
end.
然后
通过proc_lib:init_ack()函数，向Starter进程（也就是调用gen_server:start()进程）发送返回结果消息。
proc_lib.erl
%%proc_lib.erl
init_ack(Parent, Return) ->
Parent ! {ack, self(), Return},
ok.
接受消息为之前的pro_lib的sync_start_link函数
sync_start_link(?MODULE:spawn_opt(M, F, A, [link|SpawnOpts]), Timeout).
sync_start_link(Pid, Timeout) ->
receive
{ack, Pid, Return} ->
Return; %%返回值为Return变量
{'EXIT', Pid, Reason} ->
{error, Reason}
after Timeout ->
kill_flush(Pid),
{error, timeout}
end.
如果是start启动服务器的话，这里是调用sync_start，再里面通过demonitor删除监控
sync_start({Pid, Ref}, Timeout) ->
receive
{ack, Pid, Return} ->
erlang:demonitor(Ref, [flush]),
Return;
{'DOWN', Ref, process, Pid, Reason} ->
{error, Reason}
after Timeout ->
erlang:demonitor(Ref, [flush]),
kill_flush(Pid),
{error, timeout}
end.
然后如果init_it(Mod, Args)的值匹配为{ok, {ok, State}}的话，gen_server调用loop(Parent, Name, State, Mod, infinity, HibernateAfterTimeout, Debug);接受客户端消息
loop(Parent, Name, State, Mod, infinity, HibernateAfterTimeout, Debug) ->
receive
Msg ->
decode_msg(Msg, Parent, Name, State, Mod, infinity, HibernateAfterTimeout, Debug, false)
after HibernateAfterTimeout ->
loop(Parent, Name, State, Mod, hibernate, HibernateAfterTimeout, Debug)
end;
3.2、调用服务
三个handle开头的回调函数对应着三种不同的使用服务器的方式。如下：
gen_server:call ------------- handle_call/3
gen_server:cast ------------- handle_cast/2
服务进程 ！消息 ------------- handle_info/2
gen_server:call 是有返回值的调用，同步调用；cast是无返回值的调用，即通知；而直接向服务器进程发的 消息则由handle_info处理。后面两个为异步调用。
call是有返回值的调用，也是所谓的同步调用，进程会在调用后一直等待直到回调函数返回为止。
函数形式
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是被调用的服务器，可以是服务器名，或是服务器的pid。
- 第二个参数Request会直接传给回调函数handle_call。
- 最后一个参数Timeout是超时，是可以省略的，默认值是5秒。
call是用来指挥回调函数handle_call/3干活的。
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}
| {reply,Reply,NewState,{continue,Continue}}
| {noreply,NewState} | {noreply,NewState,Timeout}
| {noreply,NewState,hibernate}
| {noreply,NewState,{continue,Continue}}
| {stop,Reason,Reply,NewState} | {stop,Reason,NewState}
Reply = term()
NewState = term()
Timeout = int()>=0 | infinity
Continue = term()
Reason = term()
- 第一个参数Request是由call传进来的，是写程序时关注和处理的重点。
- 第二个参数From是gen_server传进来的，是调用的来源，也就是哪个进程执行了call。 From的形式是{Pid, Ref}，Pid是来源进程号，而Ref是调用的标识，每一次调用 都不一样，用以区别。有了Pid，在需要向来源进程发送消息时就可以使用，但由于call 是有返回值的，一般使用返回值传递数据就好。
- 第三个参数State是服务器的状态，这是由init或是其他的handle函数生成的，可以根据需要进 行修改之后，再放回返回值中。
源码
首先是gen_server:call函数，函数里面调用的是gen:call函数
gen_server.erl
%%gen_server.erl
%%Name-服务名，Request-请求消息，Timeout-超时时间
call(Name, Request, Timeout) ->
case catch gen:call(Name, '$gen_call', Request, Timeout) of
{ok,Res} ->
Res;
{'EXIT',Reason} ->
exit({Reason, {?MODULE, call, [Name, Request, Timeout]}})
end.
gen.erl
%%Process-服务名，Label-'$gen_call',Request-请求消息，TimeOut-超时时间
call(Process, Label, Request, Timeout) when is_pid(Process),
Timeout =:= infinity orelse is_integer(Timeout) andalso Timeout >= 0 ->
do_call(Process, Label, Request, Timeout);
通过send给服务端进程发送消息，消息为 {Label, {self(), Mref}, Request}, [noconnect],其中Label的值为’$gen_call’。发送消息后，会通过receive原语接受gen_server服务端消息，这也是gen_sever:call是同步调用的原因。如果调用gen_sever:call的时候有设置超时时间，那么receive会指定超时时间，设定了进程接受消息的最长时间。
do_call(Process, Label, Request, Timeout) when is_atom(Process) =:= false ->
Mref = erlang:monitor(process, Process),
%% OTP-21:
%% Auto-connect is asynchronous. But we still use 'noconnect' to make sure
%% we send on the monitored connection, and not trigger a new auto-connect.
%%
erlang:send(Process, {Label, {self(), Mref}, Request}, [noconnect]),
receive
{Mref, Reply} ->
erlang:demonitor(Mref, [flush]),
{ok, Reply};
{'DOWN', Mref, _, _, noconnection} ->
Node = get_node(Process),
exit({nodedown, Node});
{'DOWN', Mref, _, _, Reason} ->
exit(Reason)
after Timeout ->
erlang:demonitor(Mref, [flush]),
exit(timeout)
end.
之前启动服务时，会调用的gen_server:loop函数来接受消息。发送给gen_server服务端的消息，会调用gen_server:decode_msg函数
gen_server.erl
loop(Parent, Name, State, Mod, infinity, HibernateAfterTimeout, Debug) ->
receive
Msg ->
decode_msg(Msg, Parent, Name, State, Mod, infinity, HibernateAfterTimeout, Debug, false)
after HibernateAfterTimeout ->
loop(Parent, Name, State, Mod, hibernate, HibernateAfterTimeout, Debug)
end;
在decode_msg时，匹配到第三个值，调用gen_server：handle_msg函数
decode_msg(Msg, Parent, Name, State, Mod, Time, HibernateAfterTimeout, Debug, Hib) ->
case Msg of
{system, From, Req} ->
sys:handle_system_msg(Req, From, Parent, ?MODULE, Debug,
[Name, State, Mod, Time, HibernateAfterTimeout], Hib);
{'EXIT', Parent, Reason} ->
terminate(Reason, ?STACKTRACE(), Name, undefined, Msg, Mod, State, Debug);
_Msg when Debug =:= [] ->
handle_msg(Msg, Parent, Name, State, Mod, HibernateAfterTimeout);
_Msg ->
Debug1 = sys:handle_debug(Debug, fun print_event/3,
Name, {in, Msg}),
handle_msg(Msg, Parent, Name, State, Mod, HibernateAfterTimeout, Debug1)
end.
handle_msg会有一个子句参数带’$gen_call’标签与其匹配。
handle_msg({'$gen_call', From, Msg}, Parent, Name, State, Mod, HibernateAfterTimeout) ->
Result = try_handle_call(Mod, Msg, From, State),
case Result of
{ok, {reply, Reply, NState}} ->
reply(From, Reply),
loop(Parent, Name, NState, Mod, infinity, HibernateAfterTimeout, []);
{ok, {reply, Reply, NState, Time1}} ->
reply(From, Reply),
loop(Parent, Name, NState, Mod, Time1, HibernateAfterTimeout, []);
{ok, {noreply, NState}} ->
loop(Parent, Name, NState, Mod, infinity, HibernateAfterTimeout, []);
{ok, {noreply, NState, Time1}} ->
loop(Parent, Name, NState, Mod, Time1, HibernateAfterTimeout, []);
{ok, {stop, Reason, Reply, NState}} ->
try
terminate(Reason, ?STACKTRACE(), Name, From, Msg, Mod, NState, [])
after
reply(From, Reply)
end;
Other -> handle_common_reply(Other, Parent, Name, From, Msg, Mod, HibernateAfterTimeout, State)
end;
handle_msg会调用try_handle_call函数获取Result。在try_handle_call函数里面调用回调模块的handle_call函数来处理客户端的消息，handle_call的3个参数为Msg-客户端发送的消息，From-客户端进程，State-gen_server服务端状态。
try_handle_call(Mod, Msg, From, State) ->
try
{ok, Mod:handle_call(Msg, From, State)}
catch
throw:R ->
{ok, R};
Class:R:Stacktrace ->
{'EXIT', Class, R, Stacktrace}
end.
回调模块的handle_call函数执行后，handle_msg函数里面会调用reply函数给客户端发送消息。然后再次调用loop函数，handle_call的返回值为{reply,Reply,State},这里的State会成为下一次loop函数循环的参数，也就是可以通过handle_call函数来改变服务器的状态值。
handle_msg({'$gen_call', From, Msg}, Parent, Name, State, Mod, HibernateAfterTimeout) ->
Result = try_handle_call(Mod, Msg, From, State),
case Result of
{ok, {reply, Reply, NState}} ->
reply(From, Reply),
loop(Parent, Name, NState, Mod, infinity, HibernateAfterTimeout, []);
这里的{To,Tag}等于sned发送消息的{self(),Mref}
reply({To, Tag}, Reply) ->
catch To ! {Tag, Reply},
ok.
cast是没有返回值的调用，一般把它叫做通知。它是一个“异步”的调用，调用后会直接收到 ok，无需等待回调函数执行完毕。
cast(ServerRef, Request) -> ok
Types
ServerRef = Name | {Name,Node} | {global,GlobalName}
| {via,Module,ViaName} | pid()
Node = atom()
GlobalName = ViaName = term()
Request = term()
它的形式是gen_server:cast(ServerRef, Request)。参数含义 与call相同。由于不需要等待返回，所以没必要设置超时，没有第三个参数。
在多节点的情况下，可以用abcast，向各节点上的具有指定名字的服务进程发通知。
cast们对应的回调函数是handle_cast/2，具体为：handle_cast(Msg, State)。 第一个参数是由cast传进去的，第二个是服务器状态，和call类似，不多说。
handel_cast/2的返回值通常是{noreply, NewState}，这可以用来改变服务器状态， 或是{stop, Reason, NewState}，这会停止服务器。通常来说，停止服务器的命令用 cast来实现比较多。
Module:handle_cast(Request, State) -> Result
Types
Request = term()
State = term()
Result = {noreply,NewState} | {noreply,NewState,Timeout}
| {noreply,NewState,hibernate}
| {noreply,NewState,{continue,Continue}}
| {stop,Reason,NewState}
NewState = term()
Timeout = int()>=0 | infinity
Continue = term()
Reason = term()
源码
gen_server.erl
cast({global,Name}, Request) ->
catch global:send(Name, cast_msg(Request)),
ok;
cast({via, Mod, Name}, Request) ->
catch Mod:send(Name, cast_msg(Request)),
ok;
cast({Name,Node}=Dest, Request) when is_atom(Name), is_atom(Node) ->
do_cast(Dest, Request);
cast(Dest, Request) when is_atom(Dest) ->
do_cast(Dest, Request);
cast(Dest, Request) when is_pid(Dest) ->
do_cast(Dest, Request).
如果我们的参数是{Dest,Request},就会匹配到第四个值，会调用do_cast函数。
do_cast(Dest, Request) ->
do_send(Dest, cast_msg(Request)),
ok.
do_cast函数会调用do_send函数，在调用do_send函数前，会调用cast_msg函数对消息进行封装
cast_msg函数主要是封装消息，带上了’$gen_cast’标签
cast_msg(Request) -> {'$gen_cast',Request}.
de_send通过send给服务端发送消息，发送消息后，没有想call一样接受服务端消息，发送消息后直接返回ok,这也是cast是异步调用的原因。
do_send(Dest, Msg) ->
try erlang:send(Dest, Msg)
catch
error:_ -> ok
end,
ok.
再之前上面讲call的时候，已经讲过，启动服务器后，会调用loop接受消息。最终会调用handle_msg函数，handle_cast发送的消息与handle_msg(Msg, Parent, Name, State, Mod, HibernateAfterTimeout)子句匹配。
handle_msg(Msg, Parent, Name, State, Mod, HibernateAfterTimeout) ->
Reply = try_dispatch(Msg, Mod, State),
handle_common_reply(Reply, Parent, Name, undefined, Msg, Mod, HibernateAfterTimeout, State).
在handle_msg函数里面会调用try_dispatch/3函数，try_dispatch函数有一个带’$gen_cast’标签的子句与之匹配，
try_dispatch({'$gen_cast', Msg}, Mod, State) ->
try_dispatch(Mod, handle_cast, Msg, State);
try_dispatch(Info, Mod, State) ->
try_dispatch(Mod, handle_info, Info, State).
然后调用try_dispatch(Mod, handle_cast, Msg, State)函数，在里面，调用MOd:func函数，也就是回调模块的handle_cast函数。
handle_cast(_Msg，State) -> {noreply，state}.
try_dispatch(Mod, Func, Msg, State) ->
try
{ok, Mod:Func(Msg, State)}
catch
throw:R ->
{ok, R};
error:undef = R:Stacktrace when Func == handle_info ->
case erlang:function_exported(Mod, handle_info, 2) of
false ->
?LOG_WARNING(
#{label=>{gen_server,no_handle_info},
module=>Mod,
message=>Msg},
#{domain=>[otp],
report_cb=>fun gen_server:format_log/2,
error_logger=>
#{tag=>warning_msg,
report_cb=>fun gen_server:format_log/1}}),
{ok, {noreply, State}};
true ->
{'EXIT', error, R, Stacktrace}
end;
Class:R:Stacktrace ->
{'EXIT', Class, R, Stacktrace}
end.
在try_dispathch执行完成后，在handle_msg函数里面会调用handle_common_reply(Reply, Parent, Name, undefined, Msg, Mod, HibernateAfterTimeout, State).
handle_common_reply函数又会重新调用loop函数循环接受客户端消息，这里同样能改变服务端的状态State。
handle_common_reply(Reply, Parent, Name, From, Msg, Mod, HibernateAfterTimeout, State) ->
case Reply of
{ok, {noreply, NState}} ->
loop(Parent, Name, NState, Mod, infinity, HibernateAfterTimeout, []);
{ok, {noreply, NState, Time1}} ->
loop(Parent, Name, NState, Mod, Time1, HibernateAfterTimeout, []);
{ok, {stop, Reason, NState}} ->
terminate(Reason, ?STACKTRACE(), Name, From, Msg, Mod, NState, []);
{'EXIT', Class, Reason, Stacktrace} ->
terminate(Class, Reason, Stacktrace, Name, From, Msg, Mod, State, []);
{ok, BadReply} ->
terminate({bad_return_value, BadReply}, ?STACKTRACE(), Name, From, Msg, Mod, State, [])
end.
总结
通过源代码查看，可以看出，call和cast在通过send给服务端发送消息后，call会用recevie接受服务端消息，而cast通过send给服务端发送消息后，直接返回ok。
原生消息
原生消息是指不通过call或cast，直接发往服务器进程的消息，有些书上译成“带外消息”。 比方说网络套接字socket发来的消息、别的进程用!发过来的消息、跟服务器建立链接的进程死掉了， 发来{‘EXIT’, Pid, Why}等等。一般写程序要尽量用API，不要直接用!向服务器进程发消息， 但对于socket一类的依赖于消息的应用，就不得不处理原生消息了。
4> AreaPid = whereis(area_server).
<0.93.0>
5> AreaPid ! {hello}.
area_server handle_info Satate:1
{hello}
6>
上面讲过，loop循环里面接受时候，最终会调用handle_msg处理消息。
而原生消息与之匹配的有
handle_msg(Msg, Parent, Name, State, Mod, HibernateAfterTimeout) ->
Reply = try_dispatch(Msg, Mod, State),
handle_common_reply(Reply, Parent, Name, undefined, Msg, Mod, HibernateAfterTimeout, State).
调用try_dispath函数，与try_dispath函数对应的try_dispatch(Info, Mod, State)
try_dispatch(Info, Mod, State) ->
try_dispatch(Mod, handle_info, Info, State).
原生消息使用handle_info/2处理，具体为handle_info(Info, State)。其中Info是 发过来的消息的内容。回复和handle_cast是一样的。
3.3、停止服务器
上面介绍的handle函数返回{stop,…}，就会使用回调函数terminate/2进行扫尾工作,或者直接调用gen_server:stop()函数直接终止服务器。 典型的如关闭已打开的资源、文件、网络连接，打log做记录，通知别的进程“我要死啦”， 或是“信春哥，满血复活”。
可以调用gen_server:stop()函数
stop(ServerRef) -> ok
OTP 18.0
stop(ServerRef, Reason, Timeout) -> ok
Types
ServerRef = Name | {Name,Node} | {global,GlobalName}
| {via,Module,ViaName} | pid()
Node = atom()
GlobalName = ViaName = term()
Reason = term()
Timeout = int()>0 | infinity
命令通用服务器以指定的原因退出并等待它终止。gen_server进程会调用Module:terminat在退出前。
如果服务器以预期的原因终止，则该函数返回ok。除了normal、 shutdown或{shutdown,Term}之外的任何其他原因都会导致使用logger(3)发出错误报告 。默认的Reason是normal。
Module:terminate(Reason, State)
Types
Reason = normal | shutdown | {shutdown,term()} | term()
State = term()
该函数在即将终止时由gen_server进程调用。它与Module:init/1相反， 并进行任何必要的清理。当它返回时，gen_server进程以Reason终止。返回值被忽略。