-type action() ::
          postpone |
          {postpone, Postpone :: postpone()} |
          {next_event, EventType :: event_type(), EventContent :: event_content()} |
          {change_callback_module, NewModule :: module()} |
          {push_callback_module, NewModule :: module()} |
          pop_callback_module |
          enter_action().

状态转换时的操作，或启动服务器时的操作。

这些转换动作可以通过从状态回调中返回它们来调用，当使用事件调用时，从Module:init/1返回，或者通过将它们传递给enter_loop/4,5,6来调用。它们在状态进入调用中是不允许的。

动作按照包含列表的顺序执行。

设置转换选项的动作会覆盖任何先前相同类型的动作，因此包含列表中的最后一个动作胜出。例如，最后一个postpone/0会覆盖列表中任何先前的postpone/0。

• {postpone, Value} - 为此状态转换设置transition_option() postpone/0。当从Module:init/1返回或传递给enter_loop/4,5,6时，此动作将被忽略，因为在这些情况下没有要推迟的事件。

  postpone 等同于 {postpone, true}。

• {next_event, EventType, EventContent} - 此动作不设置任何transition_option()，而是存储指定的EventType和EventContent，以便在所有动作执行后插入。

  存储的事件会作为下一个要处理的事件插入队列中，排在任何已排队的事件之前。这些存储的事件的顺序会保留，因此包含列表中的第一个next_event将成为第一个要处理的事件。

  当您想要可靠地区分以这种方式插入的事件与任何外部事件时，应使用internal类型的事件。

• {change_callback_module, NewModule} - 将回调模块更改为 NewModule，该模块将在调用所有后续状态回调时使用。
  自 OTP 22.3 起。

  gen_statem 引擎将通过在下一个状态回调之前调用NewModule:callback_mode/0来找出NewModule的回调模式。

  更改回调模块不会以任何方式影响状态转换，它只会更改处理事件的模块。请注意，NewModule中的所有相关回调函数，如状态回调、NewModule:code_change/4、NewModule:format_status/1和NewModule:terminate/3必须能够处理旧模块的状态和数据。

• {push_callback_module, NewModule} - 将当前回调模块推送到回调模块的内部堆栈的顶部，并将回调模块更改为NewModule。其他方面类似于上面的{change_callback_module, NewModule}。
  自 OTP 22.3 起。

• pop_callback_module - 从回调模块的内部堆栈中弹出顶部模块，并将回调模块更改为弹出的模块。如果堆栈为空，则服务器会失败。其他方面类似于上面的{change_callback_module, NewModule}。
  自 OTP 22.3 起。

-type callback_mode() :: state_functions | handle_event_function.

每个状态一个函数或一个通用的事件处理程序。

回调模式 通过 Module:callback_mode/0 的返回值选择。

• state_functions - 状态必须是 state_name/0 类型，并且每个状态使用一个回调函数，即 Module:StateName/3。

• handle_event_function - 状态可以是任何项，并且回调函数 Module:handle_event/4 用于所有状态。

当启动 gen_statem 时，在代码更改之后，以及在使用任何动作 change_callback_module、push_callback_module 或 pop_callback_module 更改回调模块之后，会调用函数 Module:callback_mode/0。结果会缓存起来，供后续调用 状态回调 时使用。

-type callback_mode_result() :: callback_mode() | [callback_mode() | state_enter()].

来自 Module:callback_mode/0 的返回值。

这是从 Module:callback_mode/0 返回的类型，用于选择 回调模式，以及是否执行 状态进入调用。

-type data() :: term().

服务器的通用状态数据。

状态机实现要在其中存储其需要的任何服务器数据的项。这与 state/0 本身的区别在于，此数据中的更改不会导致推迟的事件重试。因此，如果此数据中的更改会更改处理的事件集，则该数据项应改为 state/0 的一部分。

-type enter_action() ::
          hibernate | {hibernate, Hibernate :: hibernate()} | timeout_action() | reply_action().

任何回调的操作：休眠、超时或回复。

当允许 action/0 时，以及从状态进入调用时，允许使用这些转换动作，并且可以通过从状态回调返回它们来调用，从 Module:init/1 返回，或者通过将它们传递给 enter_loop/4,5,6 来调用。

动作按照包含列表的顺序执行。

设置转换选项的动作会覆盖任何先前相同类型的动作，因此包含列表中的最后一个动作胜出。例如，最后一个event_timeout/0会覆盖列表中任何先前的event_timeout/0。

• {hibernate, Value} - 为此状态转换设置transition_option/0 hibernate/0。

  hibernate 等同于 {hibernate, true}。

-type enter_loop_opt() ::
          {hibernate_after, HibernateAfterTimeout :: timeout()} | {debug, Dbgs :: [sys:debug_option()]}.

用于 enter_loop/4,5,6、start/3,4、start_link/3,4 和 start_monitor/3,4 函数的服务器启动选项。

请参阅start_link/4。

-type event_content() :: term().

从事件的来源发送到状态回调的事件有效负载。

请参阅 event_type，其中描述了不同事件类型的来源，以及事件的内容来源。

-type event_handler_result(StateType, DataType) ::
          {next_state, NextState :: StateType, NewData :: DataType} |
          {next_state, NextState :: StateType, NewData :: DataType, Actions :: [action()] | action()} |
          state_callback_result(action(), DataType).

处理事件后来自状态回调的返回值。

如果回调模式是 state_functions，则 StateType 为 state_name/0，如果 回调模式 是 handle_event_function，则 StateType 为 state/0。

• {next_state, NextState, NewData [, Actions]} - gen_statem 执行到 NextState 的状态转换（可能与当前状态相同），将 NewData 设置为当前服务器data/0，并执行所有Actions。如果 NextState =/= CurrentState，则状态转换是状态更改。

-type event_timeout() :: Time :: timeout() | integer().

等待事件的时间。

启动由timeout_action/0 Time 设置的计时器，或 {timeout, Time, EventContent [, Options]}。

当计时器到期时，将生成 event_type/0 timeout 类型的事件。有关如何解释 Time 和 Options 的信息，请参阅 erlang:start_timer/4。将来不一定会支持 erlang:start_timer/4 Options。

任何到达的事件都会取消此超时。请注意，重试或插入的事件算作已到达。如果状态超时零事件在此超时请求之前生成，则该事件也算作已到达。

如果 Time 是 infinity，则不会启动计时器，因为它永远不会过期。

如果 Time 是相对的，并且为 0，则实际上不会启动计时器，而是将超时事件排入队列，以确保它在任何尚未收到的外部事件之前处理，但在已排队的事件之后处理。

请注意，不可能也不需要取消此超时，因为它会被任何其他事件自动取消，这意味着每当调用可能想要取消此超时的回调时，计时器已经取消或过期。

可以使用 {timeout, update, NewEventContent} 操作更新计时器 EventContent，而不会影响过期时间。

-type event_type() :: external_event_type() | timeout_event_type() | internal.

所有事件类型：外部、超时或 内部。

internal 事件只能由状态机本身通过转换动作 next_event 生成。

-type external_event_type() :: {call, From :: from()} | cast | info.

来自 call、cast 或常规进程消息的事件；“info”。

类型 {call, From} 源自 API 函数 call/2,3 或 send_request/2。该事件包含 From，它指示使用 reply_action/0 或 reply/2,3 调用回复的对象。

类型 cast 源自 API 函数 cast/2。

类型 info 源自发送给 gen_statem 进程的常规进程消息。

-type format_status() ::
          #{state => state(),
            data => data(),
            reason => term(),
            queue => [{event_type(), event_content()}],
            postponed => [{event_type(), event_content()}],
            timeouts => [{timeout_event_type(), event_content()}],
            log => [sys:system_event()]}.

描述服务器状态的映射。

键值包括

• state - 当前状态。
• data - 状态数据。
• reason - 导致进程终止的原因。
• queue - 事件队列。
• postponed - 延迟事件的队列。
• timeouts - 活动的超时。
• log - 服务器的 sys 日志。

新的关联可能会在不事先通知的情况下添加到状态映射中。

-type from() :: {To :: pid(), Tag :: reply_tag()}.

call 事件的回复目标。

通过例如 {reply, From, Reply} 动作回复使用 call/2,3 调用 gen_statem 服务器的进程时使用的目标地址。

-type generic_timeout() :: Time :: timeout() | integer().

等待命名超时事件的时间。

启动由 timeout_action/0 {{timeout, Name}, Time, EventContent [, Options]} 设置的计时器。

当计时器到期时，会生成一个类型为 event_type/0 {timeout, Name} 的事件。有关 Time 和 Options 如何解释，请参阅 erlang:start_timer/4。未来的 erlang:start_timer/4 Options 不一定支持。

如果 Time 是 infinity，则不会启动计时器，因为它永远不会过期。

如果 Time 是相对的并且为 0，则实际上不会启动计时器，而是将超时事件放入队列，以确保在处理任何尚未接收到的外部事件之前对其进行处理。

当计时器正在运行时，使用相同的 Name 设置计时器将使用新的超时值重新启动它。因此，可以通过将其设置为 infinity 来取消特定的超时。也可以使用 {{timeout, Name}, cancel} 动作更明确地取消它。

可以使用 {{timeout, Name}, update, NewEventContent} 动作更新计时器 EventContent，而不会影响过期时间。

-type hibernate() :: boolean().

使服务器进程休眠。

如果为 true，则通过调用 proc_lib:hibernate/3 使 gen_statem 进入休眠状态，然后再进入 receive 以等待新的外部事件。

还有一个服务器启动选项 {hibernate_after, Timeout} 用于自动休眠。

注意

如果在请求休眠时有排队的事件要处理，则会进行优化，不会休眠，而是调用 erlang:garbage_collect/0，以更有效的方式模拟 gen_statem 进入休眠状态并立即被排队的事件唤醒。

-type init_result(StateType, DataType) ::
          {ok, State :: StateType, Data :: DataType} |
          {ok, State :: StateType, Data :: DataType, Actions :: [action()] | action()} |
          ignore |
          {stop, Reason :: term()} |
          {error, Reason :: term()}.

来自 Module:init/1 的返回值。

对于成功的初始化，State 是初始的 state/0，Data 是 gen_statem 的初始服务器 data/0。

当进入第一个 state 时，将执行 Actions，就像 状态回调 一样，只是强制将 postpone 动作设为 false，因为没有事件要延迟。

对于不成功的初始化，应使用 {stop, Reason}、{error, Reason} 或 ignore；请参阅 start_link/3,4。

自 OTP 26.0 起允许使用 {error, Reason}。

自 OTP 19.1 起存在 {ok, ...} 元组，在此之前它们没有 ok 标签。这是在 OTP 20.0 中 gen_statem 替换 gen_fsm 之前。

-type postpone() :: boolean().

推迟事件以便稍后处理。

如果为 true，则延迟当前事件。在状态更改（NextState =/= State）后，将重试该事件。

-type reply_action() :: {reply, From :: from(), Reply :: term()}.

回复 call/2,3。

可以通过从 状态回调、从 Module:init/1 返回，或将其传递给 enter_loop/4,5,6 来调用此转换动作。

它不设置任何 transition_option()，而是回复 call/3 中等待回复的调用者。From 必须是调用 状态回调 时 {call, From} 参数中的项。

请注意，由于此服务器中之前没有调用 状态回调，因此从 Module:init/1 或 enter_loop/4,5,6 中使用此操作会很奇怪，甚至有点像魔法。

-opaque reply_tag()

将回复与相应请求关联的句柄。

-opaque request_id()

不透明的请求标识符。有关详细信息，请参阅 send_request/2。

-opaque request_id_collection()

不透明的请求标识符 (request_id/0) 集合。

每个请求标识符都可以与用户选择的标签关联。有关详细信息，请参阅 reqids_new/0。

-type response_timeout() :: timeout() | {abs, integer()}.

异步调用的响应超时。

用于设置等待使用 receive_response/2、receive_response/3、wait_response/2 或 wait_response/3 响应的最长时间限制。使用的时间单位是 毫秒。

当前有效的值

• 0..4294967295 - 相对于当前时间的超时，单位为毫秒。

• infinity - 无限超时。也就是说，操作永远不会超时。

• {abs, Timeout} - 绝对的 Erlang 单调时间超时，单位为毫秒。也就是说，当 erlang:monotonic_time(millisecond) 返回的值大于或等于 Timeout 时，操作将超时。Timeout 不得指定超过 4294967295 毫秒的未来时间。当你有一个对应于整个请求集合的响应截止时间 (request_id_collection/0) 时，使用绝对值指定超时特别方便，因为你不必反复重新计算截止时间之前的相对时间。

-type server_name() ::
          {local, atom()} | {global, GlobalName :: term()} | {via, RegMod :: module(), Name :: term()}.

服务器名称规范：local、global 或 via 注册。

启动 gen_statem 服务器时使用的名称规范。请参阅下面的 start_link/3 和 server_ref/0。

-type server_ref() ::
          pid() |
          (LocalName :: atom()) |
          {Name :: atom(), Node :: atom()} |
          {global, GlobalName :: term()} |
          {via, RegMod :: module(), ViaName :: term()}.

服务器规范：pid/0 或已注册的 server_name/0。

在 call/2,3 中使用以指定服务器。

它可以是

• pid() | LocalName - gen_statem 在本地注册。

• {Name, Node} - gen_statem 在另一个节点上本地注册。

• {global, GlobalName} - gen_statem 在 global 中全局注册。

• {via, RegMod, ViaName} - gen_statem 在一个替代的进程注册表中注册。注册表回调模块 RegMod 需导出函数 register_name/2、unregister_name/1、whereis_name/1 和 send/2，这些函数的行为应与 global 中的相应函数类似。因此，{via, global, GlobalName} 与 {global, GlobalName} 相同。

-type start_mon_ret() :: {ok, {pid(), reference()}} | ignore | {error, term()}.

来自 start_monitor/3,4 函数的返回值。

与 start_link/4 相同，但成功返回时会将进程 ID 和 监视引用 包装在 {ok, {pid(),reference()}} 元组中。

-type start_opt() ::
          {timeout, Time :: timeout()} | {spawn_opt, [proc_lib:start_spawn_option()]} | enter_loop_opt().

用于 start/3,4、start_link/3,4 和 start_monitor/3,4 函数的服务器启动选项。

请参阅start_link/4。

-type start_ret() :: {ok, pid()} | ignore | {error, term()}.

来自 start/3,4 和 start_link/3,4 函数的 返回值。

请参见 start_link/4。

-type state() :: state_name() | term().

状态名称或状态术语。

如果 回调模式 为 handle_event_function，则状态可以是任意项。在状态更改 (NextState =/= State) 后，所有延迟的事件都会重试。

假设比较两个状态是否严格相等是一个快速操作，因为对于每个状态转换，gen_statem 引擎必须推断它是否是状态更改。

注意

通常，状态项越小，比较速度越快。

请注意，如果为状态转换返回“相同”的状态项（或者使用了没有 NextState 字段的返回操作），则相等性比较始终是快速的，因为可以从项句柄中看到这一点。

但是，如果返回新构造的状态项，则必须遍历旧状态项和新状态项，直到找到不相等的地方，或者直到两个项都完全遍历完毕。

因此，可以使用比较速度快的大型状态项，但很容易意外出错。使用小型状态项是安全的选择。

-type state_callback_result(ActionType, DataType) ::
          {keep_state, NewData :: DataType} |
          {keep_state, NewData :: DataType, Actions :: [ActionType] | ActionType} |
          keep_state_and_data |
          {keep_state_and_data, Actions :: [ActionType] | ActionType} |
          {repeat_state, NewData :: DataType} |
          {repeat_state, NewData :: DataType, Actions :: [ActionType] | ActionType} |
          repeat_state_and_data |
          {repeat_state_and_data, Actions :: [ActionType] | ActionType} |
          stop |
          {stop, Reason :: term()} |
          {stop, Reason :: term(), NewData :: DataType} |
          {stop_and_reply, Reason :: term(), Replies :: [reply_action()] | reply_action()} |
          {stop_and_reply,
           Reason :: term(),
           Replies :: [reply_action()] | reply_action(),
           NewData :: DataType}.

来自任何 状态回调 的返回值。

ActionType 如果状态回调是通过 状态进入调用 调用的，则为 enter_action/0，如果状态回调是通过事件调用的，则为 action/0。

• {keep_state, NewData [, Actions]} - 与 {next_state, CurrentState, NewData [, Actions]} 相同。

• keep_state_and_data | {keep_state_and_data, Actions} - 与 {keep_state, CurrentData [, Actions]} 相同。

• {repeat_state, NewData [, Actions]} - 如果 gen_statem 运行带有 状态进入调用，则重复状态进入调用，请参见类型 transition_option/0。除此之外，{repeat_state, NewData [, Actions]} 与 {keep_state, NewData [, Actions]} 相同。

• repeat_state_and_data | {repeat_state_and_data, Actions} - 与 {repeat_state, CurrentData [, Actions]} 相同。

• {stop, Reason [, NewData]} - 通过调用 Module:terminate/3 并指定 Reason 和 NewData（如果指定），终止 gen_statem。将此原因的退出信号发送到链接的进程和端口。

• stop - 与 {stop, normal} 相同。

• {stop_and_reply, Reason, Replies [, NewData]} - 发送所有 Replies，然后像使用 {stop, Reason [, NewData]} 一样终止 gen_statem。

所有这些项都是元组或原子，并且在 gen_statem 的所有未来版本中都将如此。

-type state_enter() :: state_enter.

状态进入调用的回调模式 修饰符：原子 state_enter。

两种回调模式都可以使用状态进入调用，这通过将 state_enter 标志添加到 回调模式 从 Module:callback_mode/0 返回的值中来选择。

如果 Module:callback_mode/0 返回包含 state_enter 的列表，则 gen_statem 引擎将在每次状态更改时，即 NextState =/= CurrentState，使用参数 (enter, OldState, Data) 或 (enter, OldState, State, Data) 调用 状态回调，具体取决于 回调模式。

这可能看起来像一个事件，但实际上是在前一个 状态回调 返回后，并且在将任何事件传递到新的 状态回调 之前执行的调用。请参见 Module:StateName/3 和 Module:handle_event/4。通过从状态回调返回 repeat_state 或 repeat_state_and_data 操作，可以重复执行状态进入调用而无需进行状态更改。

如果 Module:callback_mode/0 未返回包含 state_enter 的列表，则不会执行状态进入调用。

如果 Module:code_change/4 应该转换状态，则将其视为状态重命名而不是状态更改，这不会导致状态进入调用。

请注意，在进入初始状态之前将执行状态进入调用，这可以看作是从无状态到初始状态的状态更改。在这种情况下，OldState =:= State，这对于后续状态更改不会发生，但在重复状态进入调用时会发生。

-type state_enter_result(State, DataType) ::
          {next_state, State, NewData :: DataType} |
          {next_state, State, NewData :: DataType, Actions :: [enter_action()] | enter_action()} |
          state_callback_result(enter_action(), DataType).

在状态进入调用之后，来自状态回调的返回值。

State 是当前状态，不能更改，因为状态回调是通过 状态进入调用 调用的。

• {next_state, State, NewData [, Actions]} - gen_statem 执行到 State 的状态转换，该状态必须等于当前状态，设置 NewData，并执行所有 Actions。

-type state_name() :: atom().

在 回调模式 state_functions 中的状态名称。

如果 回调模式 为 state_functions，则状态必须是原子。在状态更改 (NextState =/= State) 后，所有延迟的事件都会重试。请注意，状态 terminate 不能使用，因为它会与可选回调函数 Module:terminate/3 冲突。

-type state_timeout() :: Time :: timeout() | integer().

在当前状态下等待的时间。

启动由 timeout_action/0 或 {state_timeout, Time, EventContent [, Options]} 设置的定时器。

当定时器到期时，将生成 event_type/0 state_timeout 类型的事件。有关如何解释 Time 和 Options 的信息，请参见 erlang:start_timer/4。未来 erlang:start_timer/4 的 Options 不一定会受支持。

如果正在运行，则状态更改会取消此定时器。也就是说，如果启动此定时器的 timeout_action/0 是状态更改的 action/0 列表的一部分，NextState =/= CurrentState，则定时器在 NextState 中运行。

如果状态机保持在该新状态（现在是当前状态），则定时器将运行直到到期，从而创建超时事件。如果状态机从当前状态更改状态，则定时器将被取消。在从当前状态进行状态更改期间，可以为下一个 NextState 启动新的状态超时。

如果启动此定时器的 timeout_action/0 是状态转换（而不是状态更改）的 action/0 列表的一部分，则定时器在当前状态下运行。

如果 Time 是 infinity，则不会启动计时器，因为它永远不会过期。

如果 Time 是相对的且为 0，则实际上不会启动定时器，而是将超时事件排队，以确保它在任何尚未接收到的外部事件之前得到处理。

在定时器运行时设置此定时器将使用新的超时值重新启动它。因此，可以通过将其设置为 infinity 来取消此超时。也可以使用 {state_timeout, cancel} 更明确地取消它。

可以使用 {state_timeout, update, NewEventContent} 操作更新定时器 EventContent，而不会影响到期时间。

-type timeout_action() ::
          (Time :: event_timeout()) |
          {timeout, Time :: event_timeout(), EventContent :: event_content()} |
          {timeout,
           Time :: event_timeout(),
           EventContent :: event_content(),
           Options :: timeout_option() | [timeout_option()]} |
          {{timeout, Name :: term()}, Time :: generic_timeout(), EventContent :: event_content()} |
          {{timeout, Name :: term()},
           Time :: generic_timeout(),
           EventContent :: event_content(),
           Options :: timeout_option() | [timeout_option()]} |
          {state_timeout, Time :: state_timeout(), EventContent :: event_content()} |
          {state_timeout,
           Time :: state_timeout(),
           EventContent :: event_content(),
           Options :: timeout_option() | [timeout_option()]} |
          timeout_cancel_action() |
          timeout_update_action().

事件超时、通用超时或状态超时。

可以通过从 状态回调、从 Module:init/1 返回这些转换操作，或将其传递给 enter_loop/4,5,6 来调用它们。

这些超时操作设置超时 转换选项。

• Time - 是 {timeout, Time, Time} 的缩写，也就是说，超时消息是超时时间。存在此形式是为了允许 状态回调 返回值 {next_state, NextState, NewData, Time}，如 gen_fsm 中所示。

• {timeout, Time, EventContent [, Options]} - 将 transition_option/0 event_timeout/0 设置为 Time，其中包含 EventContent 和超时选项 Options。

• {{timeout,Name}, Time, EventContent [, Options]} - 将 transition_option/0 generic_timeout/0 设置为 Time，用于超时 Name，并包含 EventContent 和超时选项 Options。
  自 OTP 20.0 起.

• {state_timeout, Time, EventContent [, Options]} - 将 transition_option/0 state_timeout/0 设置为 Time，并包含 EventContent 和超时选项 Options。
  自 OTP 19.3 起.

-type timeout_cancel_action() ::
          {timeout, cancel} | {{timeout, Name :: term()}, cancel} | {state_timeout, cancel}.

比将其设置为“无限”更清晰地取消超时的方法。

一直以来，都可以使用 timeout_action/0 和 Time = infinity 来取消超时。因为设置新的超时时间会覆盖正在运行的计时器，并且将时间设置为 infinity 会优化为不设置计时器（它永远不会过期）。使用此操作可以更清晰地显示意图。

-type timeout_event_type() :: timeout | {timeout, Name :: term()} | state_timeout.

事件超时、通用超时或 状态超时。

状态机可以使用相应的 timeout_action/0 为自身生成的超时事件类型

简而言之，使用 EventType 设置超时的操作是 {EventType, Time, ...}。

-type timeout_option() :: {abs, Abs :: boolean()}.

超时计时器启动选项，用于选择过期绝对时间。

如果 Abs 为 true，则启动绝对计时器；如果为 false，则启动相对计时器，这是默认设置。有关详细信息，请参阅 erlang:start_timer/4。

-type timeout_update_action() ::
          {timeout, update, EventContent :: event_content()} |
          {{timeout, Name :: term()}, update, EventContent :: event_content()} |
          {state_timeout, update, EventContent :: event_content()}.

更新 EventContent，而不影响过期时间。

为正在运行的超时计时器设置新的 EventContent。有关如何启动超时，请参阅 timeout_action()。

如果此类型的超时未激活，则会像以相对 Time = 0 启动超时时一样插入超时事件。这是一个立即过期的超时自动启动，因此如果例如通用超时名称拼写错误，则会出现噪声。

-type transition_option() ::
          postpone() | hibernate() | event_timeout() | generic_timeout() | state_timeout().

由 操作设置的状态转换选项。

这些决定了在状态转换期间发生的事情。当 状态回调 处理完事件并返回时，就会发生状态转换。以下是状态转换的步骤顺序

1. 所有返回的 actions 都按照出现的顺序处理。在此步骤中，将发送由任何 reply_action/0 生成的所有回复。其他操作设置 transition_option/0，这些选项将在后续步骤中生效。

2. 如果使用了 状态进入调用，则无论是初始状态还是回调结果 repeat_state 或 repeat_state_and_data 中的一个，gen_statem 引擎都会使用参数 (enter, State, Data) 或 (enter, State, State, Data)（取决于 回调模式）调用当前状态回调，并在返回时再次从该序列的顶部开始。

   如果使用了 状态进入调用，并且状态发生变化，则 gen_statem 引擎会使用参数 (enter, OldState, Data) 或 (enter, OldState, State, Data)（取决于 回调模式）调用新的状态回调，并在返回时再次从该序列的顶部开始。

3. 如果 postpone/0 为 true，则当前事件将被延迟。

4. 如果这是状态更改，则传入事件的队列将被重置为从最早的延迟事件开始。

5. 所有使用 action/0 next_event 存储的事件都将被插入到先前排队的事件之前处理。

6. 将处理超时计时器 event_timeout/0、generic_timeout/0 和 state_timeout/0。保证零时间的超时将在任何外部尚未接收到的事件之前传递到状态机。因此，如果请求了这样的超时，则会将相应的超时零事件作为最新接收的事件排队；也就是说，在已经排队的事件（如插入和延迟的事件）之后。

   任何事件都会取消 event_timeout/0，因此只有当事件队列为空时，才会生成零时间的事件超时。

   状态更改 会取消 state_timeout/0，并且此类型的任何新转换选项都属于新状态，即 state_timeout/0 应用于状态机进入的状态。

7. 如果存在排队的事件，则使用最早排队的事件调用可能新状态的 状态回调，并且我们再次从该序列的顶部开始。

8. 否则，gen_statem 将进入 receive 或休眠状态（如果 hibernate/0 为 true），以等待下一条消息。在休眠状态下，下一个非系统事件会唤醒 gen_statem，或者说，下一条传入消息会唤醒 gen_statem，但如果是系统事件，它会立即返回休眠状态。当新消息到达时，将使用相应的事件调用 状态回调，并且我们再次从该序列的顶部开始。

注意

零超时（时间为 0 的超时）的行为与 Erlang 的 receive ... after 0 ... end 略有不同。

后者会在有消息时接收一条消息，而使用 timeout_action/0 {timeout, 0} 则不会接收任何外部事件。

gen_server 的超时工作方式类似于 Erlang 的 receive ... after 0 ... end，与 gen_statem 相反。