-spec abcast(Name :: atom(), Request :: term()) -> abcast.

将请求投射到多个节点。

等效于 abcast(Nodes, Name, Request)，其中 Nodes 是连接到调用节点的所有节点，包括调用节点本身。

-spec abcast(Nodes :: [node()], Name :: atom(), Request :: term()) -> abcast.

将请求投射到多个节点。

将异步请求发送到指定节点上本地注册为 Name 的 gen_server 进程。该函数会立即返回，并忽略不存在的节点，或 gen_server Name 不存在的节点。gen_server 进程会调用 Module:handle_cast/2 来处理该请求。

有关参数的说明，请参阅 multi_call/2,3,4。

-spec call(ServerRef :: server_ref(), Request :: term()) -> Reply :: term().

等效于 call(ServerRef, Request, 5000)。

-spec call(ServerRef :: server_ref(), Request :: term(), Timeout :: timeout()) -> Reply :: term().

调用服务器：发送请求并等待响应。

通过发送请求并等待直到收到回复或发生超时，对 gen_server 进程的 ServerRef 进行同步调用。gen_server 进程会调用 Module:handle_call/3 来处理该请求。

另请参阅 ServerRef 的类型 server_ref/0。

Request 是作为第一个参数传递给 Module:handle_call/3 的任何项。

Timeout 是一个整数，指定等待回复的毫秒数，或者使用原子 infinity 无限期等待。如果在指定时间内没有收到回复，此函数将使用包含 Reason = timeout 的退出项退出调用进程，如下所述。

注意

在 OTP 24 之前，如果调用者使用 (try...)catch 来避免进程退出，并且服务器恰好回复较晚，则它可能稍后到达进程消息队列。因此，调用进程在捕获超时退出后，必须准备好接收 {reference(), _} 形式的垃圾消息，并适当处理它们（丢弃它们），以防止它们阻塞进程消息队列，或被误认为其他消息。

从 OTP 24 开始，gen_server:call 使用进程别名，因此不会收到迟到的回复。

返回值 Reply 从 Module:handle_call/3 的返回值传递而来。

此调用可能会使调用进程退出，退出项的形式为 {Reason, Location}，其中 Location = {gen_server, call, ArgList}，Reason 可以是（至少）以下之一：

• timeout - 如上所述，在等待 Timeout 毫秒以获得回复后，调用被中止。

• noproc - ServerRef 通过名称引用服务器（它不是 pid/0），并且查找服务器进程失败，或者 pid/0 已经终止。

• {nodedown,Node} - ServerRef 引用远程节点 Node 上的服务器，并且与该节点的连接失败。

• calling_self - 对 self/0 的调用将无限期地挂起。

• shutdown - 服务器在调用期间被其主管停止。另请参阅 stop/3。

• normal
{shutdown,Term} - 服务器在调用期间停止，原因是从其回调之一返回了 {stop,Reason,_} 而没有回复此调用。另请参阅 stop/3。

• _OtherTerm - 服务器进程在调用期间退出，原因是 Reason。可能是因为从其回调之一返回了 {stop,Reason,_}（没有回复此调用），引发了异常，或者由于收到它没有捕获的退出信号。

-spec cast(ServerRef :: server_ref(), Request :: term()) -> ok.

将请求投射到服务器。

向 gen_server ServerRef 发送异步请求并立即返回 ok，忽略目标节点或 gen_server 进程是否存在。

gen_server 进程调用 Module:handle_cast(Request, _) 来处理请求。

-spec check_response(Msg, ReqId) -> Result
                        when
                            Msg :: term(),
                            ReqId :: request_id(),
                            Response ::
                                {reply, Reply :: term()} | {error, {Reason :: term(), server_ref()}},
                            Result :: Response | no_reply.

检查收到的消息是否为请求响应。

检查 Msg 是否是与请求标识符 ReqId 对应的响应。请求必须由 send_request/2 发出，并且由调用此函数的同一进程发出。

如果 Msg 是对句柄 ReqId 的回复，则请求的结果将在 Reply 中返回。否则，此函数返回 no_reply 并且不进行清理，因此应重复调用该函数，直到返回响应。

返回值 Reply 从 Module:handle_call/3 的返回值传递而来。

如果调用此函数时 gen_statem 服务器进程已死亡，即；Msg 报告服务器的死亡，则此函数将返回带有退出 Reason 的 error 返回值。

-spec check_response(Msg, ReqIdCollection, Delete) -> Result
                        when
                            Msg :: term(),
                            ReqIdCollection :: request_id_collection(),
                            Delete :: boolean(),
                            Response ::
                                {reply, Reply :: term()} | {error, {Reason :: term(), server_ref()}},
                            Result ::
                                {Response,
                                 Label :: term(),
                                 NewReqIdCollection :: request_id_collection()} |
                                no_request | no_reply.

检查收到的消息是否为集合中的请求响应。

检查 Msg 是否是与存储在 ReqIdCollection 中的请求标识符对应的响应。ReqIdCollection 的所有请求标识符必须对应于由调用此函数的进程使用 send_request/2 或 send_request/4 发出的请求。

响应中的 Label 等于与响应对应的请求标识符关联的 Label。Label 在 将请求 ID 存储在集合中时，或在使用 send_request/4 发送请求时与请求标识符关联。

与 check_response/2 相比，与特定请求标识符关联的返回结果或异常将包装在 3 元组 {Response, Label, NewReqIdCollection} 中。Response 是 check_response/2 将产生的值，Label 是与特定 请求标识符 关联的值，NewReqIdCollection 是可能已修改的请求标识符集合。

如果 ReqIdCollection 为空，将返回 no_request。

如果 Msg 不对应于 ReqIdCollection 中的任何请求标识符，则返回 no_reply。

如果 Delete 为 true，则与 Label 的关联已从生成的 NewReqIdCollection 中的 ReqIdCollection 中删除。如果 Delete 为 false，则 NewReqIdCollection 将等于 ReqIdCollection。请注意，删除关联并非没有代价，并且包含已处理请求的集合仍可由后续的 check_response/3、receive_response/3 和 wait_response/3 调用使用。

但是，如果不删除已处理的关联，则以上调用将无法检测何时没有更多未处理的请求，因此您必须以其他方式跟踪此信息，而不是依赖于 no_request 返回值。请注意，如果您将仅包含已处理或放弃的请求的关联的集合传递给此函数，它将始终返回 no_reply。

-spec enter_loop(Module :: module(), Options :: [enter_loop_opt()], State :: term()) -> no_return().

等效于 enter_loop(Mod, Options, State, self())。

-spec enter_loop(Module :: module(),
                 Options :: [enter_loop_opt()],
                 State :: term(),
                 ServerName :: server_name() | pid()) ->
                    no_return();
                (Module :: module(),
                 Options :: [enter_loop_opt()],
                 State :: term(),
                 How :: timeout() | hibernate | {continue, term()}) ->
                    no_return().

使调用进程成为 gen_server 进程。

使用与 enter_loop(Module, Options, State, ServerName, infinity) 等效的参数 ServerName。

使用与 enter_loop(Module, Options, State, self(), How) 等效的参数 How。

-spec enter_loop(Module :: module(),
                 Options :: [enter_loop_opt()],
                 State :: term(),
                 ServerName :: server_name() | pid(),
                 Timeout :: timeout()) ->
                    no_return();
                (Module :: module(),
                 Options :: [enter_loop_opt()],
                 State :: term(),
                 ServerName :: server_name() | pid(),
                 Hibernate :: hibernate) ->
                    no_return();
                (Module :: module(),
                 Options :: [enter_loop_opt()],
                 State :: term(),
                 ServerName :: server_name() | pid(),
                 Cont :: {continue, term()}) ->
                    no_return().

使调用进程成为 gen_server 进程。

不会返回，而是调用进程进入 gen_server 进程接收循环并成为 gen_server 进程。该进程必须已使用 proc_lib 中的启动函数之一启动。用户负责进程的任何初始化，包括为其注册名称。

当需要比 gen_server Module:init/1 回调提供的更复杂的初始化过程时，此函数很有用。

Module、Options 和 ServerName 的含义与调用 start[_link|_monitor]/3,4 时相同，或者 ServerName 可以是匿名服务器的 self/0，这与调用没有 ServerName 参数的 enter_loop/3,4 函数相同。但是，如果指定了 ServerName（而不是 self/0），则必须在调用此函数之前按照相应方式注册该进程。

State、Timeout、Hibernate 和 Cont 的含义与 Module:init/1 的返回值中的含义相同，当使用 enter_loop/3,4,5 时，不会调用该返回值。请注意，为了遵守 gen_server 行为，需要定义这样的回调函数，并且它也可以是在通过 proc_lib 启动 gen_server 进程时使用的函数，然后调用 enter_loop/3,4,5。但是，如果这样的 Module:init/1 函数（例如，在错误情况下）无法调用 enter_loop/3,4,5，则它应返回符合 Module:init/1 类型规范的值，例如 ignore，尽管该值在返回到生成函数时将丢失。

如果调用进程不是由 proc_lib 启动函数启动的，或者如果没有按照 ServerName 进行注册，则此函数将失败。

-spec multi_call(Name :: atom(), Request :: term()) ->
                    {Replies :: [{Node :: node(), Reply :: term()}], BadNodes :: [node()]}.

并行调用多个节点上的服务器。

等效于 multi_call(Nodes, Name, Request)，其中 Nodes 是所有连接到调用节点的节点，包括调用节点本身。

-spec multi_call(Nodes :: [node()], Name :: atom(), Request :: term()) ->
                    {Replies :: [{Node :: node(), Reply :: term()}], BadNodes :: [node()]}.

等效于 multi_call(Nodes, Name, Request, infinity)。

-spec multi_call(Nodes :: [node()], Name :: atom(), Request :: term(), Timeout :: timeout()) ->
                    {Replies :: [{Node :: node(), Reply :: term()}], BadNodes :: [node()]}.

并行调用多个节点上的服务器。

通过先将请求发送到节点，然后等待回复，对指定节点上本地注册为 Name 的所有 gen_server 进程进行同步调用。节点上的 gen_server 进程调用 Module:handle_call/3 来处理请求。

该函数返回一个元组 {Replies, BadNodes}，其中 Replies 是 {Node, Reply} 元组的列表，BadNodes 是不存在的节点列表，其中 Name 不是注册的 gen_server，或者没有回复。

Nodes 是要将请求发送到的节点名称的列表。

Name 是每个 gen_server 进程的本地注册名称。

Request 是作为第一个参数传递给 Module:handle_call/3 的任何项。

Timeout 是一个整数，指定等待所有回复的毫秒数，或者使用原子 infinity 无限期等待。如果在指定时间内没有收到来自节点的回复，则该节点将添加到 BadNodes。

当从节点 Node 上的 gen_server 进程收到回复 Reply 时，{Node,Reply} 将添加到 Replies。Reply 从 Module:handle_call/3 的返回值传递而来。

警告

如果其中一个节点无法处理监视器（例如，C 或 Java 节点），并且在发送请求时未启动 gen_server 进程，但在 2 秒内启动，则此函数将等待整个 Timeout，这可能是无限的。

如果所有节点都是 Erlang 节点，则不存在此问题。

为了防止超时后的迟到回复污染调用者的消息队列，使用中间人进程来执行调用。当迟到回复到达已终止的中间人进程时，会被丢弃。

-spec receive_response(ReqId, Timeout) -> Result
                          when
                              ReqId :: request_id(),
                              Timeout :: response_timeout(),
                              Response ::
                                  {reply, Reply :: term()} | {error, {Reason :: term(), server_ref()}},
                              Result :: Response | timeout.

接收请求响应。

接收与请求标识符 ReqId 对应的响应。该请求必须由 send_request/2 发出，并且必须由调用此函数的同一进程发出。

Timeout 指定等待响应的时间。如果在指定的时间内未收到响应，此函数将返回 timeout。假设服务器在支持别名（在 OTP 24 中引入）的节点上执行，则该请求也将被放弃。也就是说，超时后将不会收到任何响应。否则，可能会在稍后收到一个滞后的响应。

返回值 Reply 从 Module:handle_call/3 的返回值传递而来。

如果 gen_server 在发送回复之前死亡，则该函数将返回错误。

receive_response/2 和 wait_response/2 之间的区别在于，receive_response/2 在超时时放弃请求，以便忽略潜在的未来响应，而 wait_response/2 则不会。

-spec receive_response(ReqIdCollection, Timeout, Delete) -> Result
                          when
                              ReqIdCollection :: request_id_collection(),
                              Timeout :: response_timeout(),
                              Delete :: boolean(),
                              Response ::
                                  {reply, Reply :: term()} | {error, {Reason :: term(), server_ref()}},
                              Result ::
                                  {Response,
                                   Label :: term(),
                                   NewReqIdCollection :: request_id_collection()} |
                                  no_request | timeout.

接收集合中的请求响应。

在 ReqIdCollection 中接收响应。ReqIdCollection 的所有请求标识符都必须对应于使用 send_request/2 或 send_request/4 发出的请求，并且所有请求都必须由调用此函数的进程发出。

响应中的 Label 是与响应对应的请求标识符关联的 Label。当 将请求 ID 添加到集合或使用 send_request/4 发送请求时，将关联请求标识符的 Label。

与 receive_response/2 相比，与特定请求标识符关联的返回结果或异常将包装在 3 元组 {Response, Label, NewReqIdCollection} 中。Response 是 receive_response/2 将会产生的值，Label 是与特定 请求标识符 关联的值，NewReqIdCollection 是一个可能经过修改的请求标识符集合。

如果 ReqIdCollection 为空，将返回 no_request。

Timeout 指定等待响应的时间。如果在指定的时间内未收到响应，该函数将返回 timeout。假设服务器在支持别名（在 OTP 24 中引入）的节点上执行，则 ReqIdCollection 标识的所有请求也将被放弃。也就是说，超时后将不会收到任何响应。否则，可能会在稍后收到滞后的响应。

receive_response/3 和 wait_response/3 之间的区别在于，receive_response/3 在超时时放弃请求，以便忽略潜在的未来响应，而 wait_response/3 则不会。

如果 Delete 为 true，则在生成的 NewReqIdCollection 中，将从 ReqIdCollection 中删除与 Label 的关联。如果 Delete 为 false，则 NewReqIdCollection 将等于 ReqIdCollection。请注意，删除关联并非没有代价，并且包含已处理请求的集合仍然可以被后续调用 receive_response/3、check_response/3 和 wait_response/3 使用。

但是，如果不删除已处理的关联，上述调用将无法检测到何时没有更多待处理的请求，因此您必须以其他方式跟踪此情况，而不是依赖 no_request 返回值。请注意，如果您将仅包含已处理或已放弃请求的关联的集合传递给此函数，它将始终阻塞，直到 Timeout 过期，然后返回 timeout。

-spec reply(Client :: from(), Reply :: term()) -> ok.

向客户端发送回复。

当回复无法在 Module:handle_call/3 的返回值中传递时，gen_server 进程可以使用此函数显式地向调用 call/2,3 或 multi_call/2,3,4 的客户端发送回复。

Client 必须是提供给 handle_call/3 回调函数的 From 参数。Reply 是作为 call/2,3 或 multi_call/2,3,4 的返回值传递回客户端的任何项。

-spec reqids_add(ReqId :: request_id(), Label :: term(), ReqIdCollection :: request_id_collection()) ->
                    NewReqIdCollection :: request_id_collection().

在集合中存储请求标识符。

存储 ReqId 并通过将此信息添加到 ReqIdCollection 并返回生成的请求标识符集合来将 Label 与请求标识符关联。

-spec reqids_new() -> NewReqIdCollection :: request_id_collection().

创建空的请求标识符集合。

返回一个新的空请求标识符集合。请求标识符集合可用于处理多个未完成的请求。

使用 send_request/2 发出的请求的请求标识符可以使用 reqids_add/3 存储在集合中。稍后，可以通过将集合作为参数传递给 receive_response/3、wait_response/3 或 check_response/3，来获取集合中与请求对应的响应。

reqids_size/1 可用于确定集合中请求标识符的数量。

-spec reqids_size(ReqIdCollection :: request_id_collection()) -> non_neg_integer().

返回 ReqIdCollection 中的请求标识符的数量。

-spec reqids_to_list(ReqIdCollection :: request_id_collection()) ->
                        [{ReqId :: request_id(), Label :: term()}].

将请求标识符集合转换为列表。

返回 {ReqId, Label} 元组的列表，这些元组对应于 ReqIdCollection 中所有请求标识符及其关联的标签。

-spec send_request(ServerRef :: server_ref(), Request :: term()) -> ReqId :: request_id().

发送异步 call 请求。

将 Request 发送到由 ServerRef 标识的 gen_server 进程，并返回一个请求标识符 ReqId。

返回值 ReqId 稍后应与 receive_response/2、wait_response/2 或 check_response/2 一起使用，以获取请求的实际结果。除了将请求标识符直接传递给这些函数外，还可以使用 reqids_add/3 将其存储在请求标识符集合中。稍后，可以通过将集合作为参数传递给 receive_response/3、wait_response/3 或 check_response/3，来获取集合中与请求对应的响应。如果要将请求标识符存储在集合中，您可能需要考虑使用 send_request/4。

调用 gen_server:receive_response(gen_server:send_request(ServerRef, Request), Timeout) 可以被视为等效于 gen_server:call(ServerRef, Request, Timeout)，忽略错误处理。

gen_server 进程调用 Module:handle_call/3 来处理请求。

有关 ServerRef 的可能值，请参见类型 server_ref/0。

Request 是作为第一个参数传递给 Module:handle_call/3 的任何项。

-spec send_request(ServerRef :: server_ref(),
                   Request :: term(),
                   Label :: term(),
                   ReqIdCollection :: request_id_collection()) ->
                      NewReqIdCollection :: request_id_collection().

发送异步 call 请求，并将其添加到请求标识符集合。

将 Request 发送到由 ServerRef 标识的 gen_server 进程。该 Label 将与操作的请求标识符关联，并添加到返回的请求标识符集合 NewReqIdCollection 中。稍后，可以通过将集合作为参数传递给 receive_response/3、wait_response/3 或 check_response/3，来获取集合中与请求对应的响应。

与调用 reqids_add(send_request(ServerRef, Request), Label, ReqIdCollection) 相同，但效率略高。

-spec start(Module :: module(), Args :: term(), Options :: [start_opt()]) -> start_ret().

启动服务器，既不链接也不注册。

与 start/4 相同，只是 gen_server 进程未在任何 名称服务中注册。

-spec start(ServerName :: server_name(), Module :: module(), Args :: term(), Options :: [start_opt()]) ->
               start_ret().

启动服务器，既不链接也不注册。

创建一个独立的 gen_server 进程，即不属于监督树的 gen_server 进程，因此没有监督者。

除此之外，请参见 start_link/4。

-spec start_link(Module :: module(), Args :: term(), Options :: [start_opt()]) -> start_ret().

启动服务器，已链接但未注册。

与 start_link/4 相同，只是 gen_server 进程未在任何 名称服务中注册。

-spec start_link(ServerName :: server_name(),
                 Module :: module(),
                 Args :: term(),
                 Options :: [start_opt()]) ->
                    start_ret().

启动服务器，已链接但未注册。

创建作为监督树一部分的 gen_server 进程。此函数应由监督者直接或间接地调用。例如，它确保 gen_server 进程作为链接到调用者（监督者）的进程生成。

gen_server 进程调用 Module:init/1 来初始化。为了确保同步的启动过程，start_link/3,4 在 Module:init/1 返回或失败之前不会返回。

ServerName 指定使用哪个名称以及现在如何注册服务器名称。有关不同的名称注册，请参见类型 server_name/0。

Module 是回调模块的名称。

Args 是作为参数传递给 Module:init/1 的任何项。

有关启动 gen_server 进程的 Options，请参见类型 start_opt/0。

有关此函数返回值的说明，请参见类型 start_ret/0。

如果 start_link/3,4 返回 ignore 或 {error, _}，则启动的 gen_server 进程已终止。如果 'EXIT' 消息已传递到调用进程（由于进程链接），则该消息已被使用。

警告

在 OTP 26.0 之前，如果启动的 gen_server 进程从 Module:init/1 返回例如 {stop, Reason}，则此函数可能在启动的 gen_server 进程终止之前返回 {error, Reason}，因此重新启动可能会失败，因为 VM 资源（例如已注册的名称）尚未注销。 一个 'EXIT' 消息可能会稍后到达调用此函数的进程。

但是，如果启动的 gen_server 进程在 Module:init/1 期间失败，则进程链接 {'EXIT', Pid, Reason} 消息会导致此函数返回 {error, Reason}，因此 'EXIT' 消息已被消耗，并且启动的 gen_server 进程已终止。

由于无法从 start_link/3,4 的返回值中区分这两种情况，因此这种不一致在 OTP 26.0 中得到了清理。

从 Module:init/1 返回 {stop, _} 和 {error, _} 的区别在于，{error, _} 会导致优雅的（“静默”）终止，因为 gen_server 进程以原因 normal 退出。

-spec start_monitor(Module :: module(), Args :: term(), Options :: [start_opt()]) -> start_mon_ret().

启动服务器，已监视但既不链接也不注册。

等同于 start_monitor/4，只是 gen_server 进程未在任何 名称服务中注册。

-spec start_monitor(ServerName :: server_name(),
                    Module :: module(),
                    Args :: term(),
                    Options :: [start_opt()]) ->
                       start_mon_ret().

启动服务器，已监视和注册，但未链接。

创建一个独立的 gen_server 进程，即不是监督树的一部分（因此没有监督者）的 gen_server 进程，并原子地设置对新创建的服务器的监视器。

除此之外，请参见 start_link/3,4。请注意，成功启动的返回值不同，它返回一个监视器 reference。请参见类型 start_mon_ret/0。

如果启动不成功，则调用方将被阻塞，直到收到监视器的 'DOWN' 消息并将其从消息队列中移除。

-spec stop(ServerRef :: server_ref()) -> ok.

等效于 stop(ServerRef, normal, infinity)。

-spec stop(ServerRef :: server_ref(), Reason :: term(), Timeout :: timeout()) -> ok.

停止服务器。

命令由 ServerRef 指定的通用服务器以指定的 Reason 退出，并等待它终止。 gen_server 进程在退出前调用 Module:terminate/2。

如果服务器以预期的原因终止，则该函数返回 ok。除 normal、shutdown 或 {shutdown,Term} 之外的任何其他原因都会使用 logger 发出错误报告。具有相同原因的退出信号会发送到链接的进程和端口。

Timeout 是一个整数，指定等待服务器终止的毫秒数，或者是原子 infinity 以无限期等待。如果服务器在指定的时间内没有终止，则该调用将以原因 timeout 退出调用进程。

如果该进程不存在，则该调用将以原因 noproc 退出调用进程，或者如果与运行服务器的远程 Node 的连接失败，则以原因 {nodedown,Node} 退出。

-spec wait_response(ReqId, WaitTime) -> Result
                       when
                           ReqId :: request_id(),
                           WaitTime :: response_timeout(),
                           Response ::
                               {reply, Reply :: term()} | {error, {Reason :: term(), server_ref()}},
                           Result :: Response | timeout.

等待请求响应。

等待对请求标识符 ReqId 的响应。该请求必须由 send_request/2 发出，并且必须由调用此函数的同一进程发出。

WaitTime 指定等待回复的时间。如果在指定时间内未收到回复，则该函数返回 timeout，并且不进行清理。因此，可以重复调用该函数，直到返回回复为止。

返回值 Reply 从 Module:handle_call/3 的返回值传递而来。

如果 gen_server 在发送回复之前死亡，则该函数将返回错误。

receive_response/2 和 wait_response/2 之间的区别在于，receive_response/2 在超时时放弃请求，以便忽略潜在的未来响应，而 wait_response/2 则不会。

-spec wait_response(ReqIdCollection, WaitTime, Delete) -> Result
                       when
                           ReqIdCollection :: request_id_collection(),
                           WaitTime :: response_timeout(),
                           Delete :: boolean(),
                           Response ::
                               {reply, Reply :: term()} | {error, {Reason :: term(), server_ref()}},
                           Result ::
                               {Response,
                                Label :: term(),
                                NewReqIdCollection :: request_id_collection()} |
                               no_request | timeout.

等待集合中的任何请求响应。

在 ReqIdCollection 中等待响应。 ReqIdCollection 的所有请求标识符必须对应于使用 send_request/2 或 send_request/4 发出的请求，并且所有请求必须由调用此函数的进程发出。

响应中的 Label 是与响应对应的请求标识符关联的 Label。当 将请求 ID 添加到集合或使用 send_request/4 发送请求时，将关联请求标识符的 Label。

与 wait_response/2 相比，与特定请求标识符关联的返回结果或异常将包装在 3 元组 {Response, Label, NewReqIdCollection} 中。Response 是 wait_response/2 本应产生的值，Label 是与特定 请求标识符 关联的值，而 NewReqIdCollection 是可能已修改的请求标识符集合。

如果 ReqIdCollection 为空，将返回 no_request。

如果在 WaitTime 过期之前没有收到响应，则返回 timeout。在收到响应并由 check_response()、receive_response() 或 wait_response() 完成之前，可以根据需要多次继续等待响应。

receive_response/3 和 wait_response/3 之间的区别在于 receive_response/3 会在超时时放弃请求，以便忽略潜在的未来响应，而 wait_response/3 则不会。

如果 Delete 为 true，则与 Label 的关联已从结果 NewReqIdCollection 中的 ReqIdCollection 中删除。如果 Delete 为 false，则 NewReqIdCollection 将等于 ReqIdCollection。请注意，删除关联并非没有代价，并且包含已处理请求的集合仍然可以被后续对 wait_response/3、check_response/3 和 receive_response/3 的调用使用。

但是，如果不删除已处理的关联，则上述调用将无法检测何时没有更多待处理的请求要处理，因此您必须以其他方式跟踪此信息，而不是依赖 no_request 返回。请注意，如果您将仅包含已处理或放弃的请求的关联的集合传递给此函数，它将始终阻塞，直到 WaitTime 过期，然后返回 timeout。