-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 報告伺服器已終止，則此函式會傳回 error 回傳值，並帶有終止 Reason。

-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。請求識別碼的 Label 在將請求 ID 加入集合時，或使用 send_request/4 發送請求時相關聯。

與 receive_response/2 相比，與特定請求識別碼相關聯的返回結果或異常將被包裝在一個三元組 {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，則與 Label 的關聯會從結果的 NewReqIdCollection 中的 ReqIdCollection 中刪除。如果 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 返回值的任何 term。

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

將請求識別碼儲存在集合中。

儲存 ReqId 並將 Label 與請求識別碼關聯，方法是將此資訊加入到 ReqIdCollection 並回傳結果的請求識別碼集合。

-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 來處理請求。

請參閱類型 server_ref/0 以了解 ServerRef 的可能值。

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。請求識別碼的 Label 在將請求 ID 加入集合時，或使用 send_request/4 發送請求時相關聯。

與 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。