8.3 网络可靠性工程
8.2 讲了「会话与消息」,这一节把可靠性讲透:Steam 网络层的可靠性由发送标志、消息号与大小上限共同约束。可靠消息由 SDK 分配单调递增的消息号,重传后仍保证恰好一次、按序投递;不可靠消息可能丢;单条消息有 512 KiB 上限;连接断开后发送返回错误。接入工程要理解这些约束,才能设计不会「发爆」「发丢关键状态」的协议。
本卷所有接口口径以 Steamworks SDK v1.65(2026-07-23) 为准。本节摘录的签名对照该版本 public/steam/isteamnetworkingsockets.h 与 public/steam/steamnetworkingtypes.h。
本章与站内既有内容的分工
- 8.2 讲 Messages 家族的会话与频道;本节讲可靠性的工程约束——消息号、重传、大小上限、断开语义。
- 8.1 的连接状态机是本节的基础(断开后发送返回
NoConnection即来自状态机)。 - lab 用纯 C++ 复现「可靠重传 + 恰好一次按序」「不可靠丢包」「大小上限」「断开拒绝发送」,不依赖 Steam 客户端运行。
可靠发送:消息号与重传
可靠消息的核心是「恰好一次、按序」。v1.65 发送入口:
// isteamnetworkingsockets.h:SendMessageToConnection / ReceiveMessagesOnConnection(SDK v1.65 头文件摘录,已删减)
virtual EResult SendMessageToConnection( HSteamNetConnection hConn, const void *pData, uint32 cbData, int nSendFlags, int64 *pOutMessageNumber, bool *pbReliable ) = 0;
virtual int ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;
工程语义:
- 消息号由 SDK 分配:
pOutMessageNumber输出本消息的编号(可靠消息才有意义),单调递增。接入工程用消息号做协议层确认(如「我收到 120,请从 121 继续」),不要在应用层再造一套序号。 - 可靠 = 重传直到确认:丢包后 SDK 自动重传,应用层只看到恰好一次、按序的交付。工程上「按序」意味着收端可能短暂落后(缺失的消息在重传路上),协议处理要容忍排序窗口。
- 可靠发送会排队:可靠消息在网络上可能累积。高频状态不要全发可靠,否则重传风暴会把管道塞满(这是联机工程最常见的失败模式)。
不可靠发送与丢包
不可靠消息是可靠性的「另一面」——不保证到达。v1.65 标志与上限:
// steamnetworkingtypes.h:k_nSteamNetworkingSend_Reliable / k_nSteamNetworkingSend_Unreliable / k_cbMaxSteamNetworkingSocketsMessageSizeSend(SDK v1.65 头文件摘录,已删减)
const int k_nSteamNetworkingSend_Unreliable = 0;
// Reliable message send. Can send up to k_cbMaxSteamNetworkingSocketsMessageSizeSend bytes in a single message.
const int k_nSteamNetworkingSend_Reliable = 8;
const int k_cbMaxSteamNetworkingSocketsMessageSizeSend = 512 * 1024;
工程语义:
- 不可靠发送可能静默丢失:发送调用本身返回成功,但网络可能把消息丢掉。接入工程不要把不可靠消息用于「必须到达」的状态;位置、心跳、日志这类可替换数据用不可靠。
- 单消息 512 KiB 上限:
k_cbMaxSteamNetworkingSocketsMessageSizeSend = 512 * 1024。超过上限的发送返回k_EResultInvalidParam。大对象(地图、模型)要切片或走创意工坊内容管道,不要塞进网络消息。 - 混用策略:协议设计时把「关键且低频」划给可靠、「高频且可替换」划给不可靠。同一连接上两类消息并行是正常的。
断开语义与连接状态
连接断开后,发送行为由状态机决定。v1.65 语义:
// steamnetworkingtypes.h:ESteamNetworkingConnectionState 关键状态(SDK v1.65 头文件摘录,已删减)
k_ESteamNetworkingConnectionState_ClosedByPeer = 4, // 对端关闭
k_ESteamNetworkingConnectionState_ProblemDetectedLocally = 5, // 本端发现问题
工程语义:
- 断开后发送返回
NoConnection:连接已失效时调用SendMessageToConnection返回k_EResultNoConnection,不再排队。接入工程要在协议层把这个返回值翻译成「重连或退出房间」。 - 重连后消息号延续:SDK 的消息号在重连后继续递增(同一连接上下文),不会重置。应用层确认号要能跨重连工作,不要假设从 0 重新开始。
- 状态机驱动重连:收到
SteamNetConnectionStatusChangedCallback_t且状态为ClosedByPeer/ProblemDetectedLocally时,清理本端句柄并发起重连(限速退避),而不是继续发送。
接口签名对照
| 头文件 | 条目 | 语义 |
|---|---|---|
isteamnetworkingsockets.h | ISteamNetworkingSockets::SendMessageToConnection | 发送(输出消息号 + 可靠标志) |
isteamnetworkingsockets.h | ISteamNetworkingSockets::ReceiveMessagesOnConnection | 接收消息 |
steamnetworkingtypes.h | k_nSteamNetworkingSend_Reliable | 可靠发送(=8,重传 + 恰好一次按序) |
steamnetworkingtypes.h | k_nSteamNetworkingSend_Unreliable | 不可靠发送(=0,可能丢) |
steamnetworkingtypes.h | k_cbMaxSteamNetworkingSocketsMessageSizeSend | 单消息上限 512 KiB |
steamnetworkingtypes.h | ESteamNetworkingConnectionState | 断开/问题状态(关闭语义) |
数据口径与来源
- 接口签名、消息号输出参数、大小上限常量:SDK v1.65
public/steam/isteamnetworkingsockets.h与public/steam/steamnetworkingtypes.h可实证(本机镜像已核对)。 - 具体丢包率、延迟、带宽:运行时数据,以官方当前为准。
以上接口口径撰写时对照 Steamworks SDK v1.65 头文件与 partner.steamgames.com 官方文档核对;登录后可见数据以官方当前为准。
可运行产物:C++ 最小验证
下面的仿真复现「网络可靠性工程」的接口工程语义:可靠发送分配单调消息号、单消息 512 KiB 上限拒绝超限、无丢包恰好一次按序投递、丢包后可靠消息重传仍恰好一次按序、不可靠消息丢失、断开后发送返回 NoConnection、重连后消息号延续不重置。它与 src/08-3-networking-reliability.cpp 逐字节一致,mock 签名对照 SDK v1.65 头文件:
// file: src/08-3-networking-reliability.cpp
// tier: L1
// verify: clang++ -std=c++20 -Wall -I. src/08-3-networking-reliability.cpp -o bin/08-3-networking-reliability && ./bin/08-3-networking-reliability
//
// mock:复现网络可靠性的接口工程语义——可靠/不可靠发送标志、单消息大小上限
// (k_cbMaxSteamNetworkingSocketsMessageSizeSend)、可靠消息重传与恰好一次按序、
// 不可靠消息丢失、连接断开后发送失败。
// 签名对照 SDK v1.65 steamnetworkingtypes.h 发送标志,非 Valve 实现。
#include "verify.h"
#include <string>
#include <vector>
namespace steam_repro {
// k_nSteamNetworkingSend_Reliable / Unreliable 对照 steamnetworkingtypes.h
const int kSendReliable = 8;
const int kSendUnreliable = 0;
// k_cbMaxSteamNetworkingSocketsMessageSizeSend 对照 steamnetworkingtypes.h
constexpr size_t kMaxMessageSizeSend = 512 * 1024;
// EResult 简化为负数便于断言
constexpr int kResultOK = 0;
constexpr int kResultInvalidParam = -1;
constexpr int kResultNoConnection = -2;
struct MockMessage {
std::string data;
int64_t msgNum = 0;
bool retransmitted = false;
};
class MockReliableTransport {
public:
bool connect() {
connected_ = true;
return true;
}
void disconnect() { connected_ = false; }
// ISteamNetworkingSockets::SendMessageToConnection:返回 EResult。
// 可靠消息分配单调消息号;不可靠消息在丢包标记下直接丢弃。
int send(const std::string& data, int flags) {
if (data.size() > kMaxMessageSizeSend) return kResultInvalidParam;
if (!connected_) return kResultNoConnection;
if ((flags & kSendReliable) == 0) {
if (dropNext_) {
dropNext_ = false;
return kResultOK; // 不可靠消息被网络丢弃,但发送调用本身成功
}
rx_.push_back({data, 0, false});
return kResultOK;
}
pending_.push_back({data, ++seq_, false});
return kResultOK;
}
// 模拟网络丢包标记:下一条不可靠消息丢失
void markNextUnreliableDrop() { dropNext_ = true; }
// 网络泵:一次传输机会。loss=true 时,未重传过的可靠消息被扣下等待重传。
void pump(bool loss) {
std::vector<MockMessage> keep;
for (MockMessage& m : pending_) {
if (loss && !m.retransmitted) {
m.retransmitted = true;
retransmits_++;
keep.push_back(m);
continue;
}
rx_.push_back(m);
}
pending_ = keep;
}
// 取回已投递消息(对应 ReceiveMessagesOnConnection)
int receive(std::string* out, int max) {
int n = 0;
std::vector<MockMessage> keep;
for (const MockMessage& m : rx_) {
if (n < max) {
out[n++] = m.data;
} else {
keep.push_back(m);
}
}
rx_ = keep;
return n;
}
int64_t lastMessageNumber() const { return seq_; }
int retransmitCount() const { return retransmits_; }
bool hasPending() const { return !pending_.empty(); }
private:
bool connected_ = false;
bool dropNext_ = false;
int64_t seq_ = 0;
int retransmits_ = 0;
std::vector<MockMessage> pending_;
std::vector<MockMessage> rx_;
};
} // namespace steam_repro
int main() {
using namespace steam_repro;
MockReliableTransport t;
t.connect();
std::string out[16];
// 1. 连接后发送可靠消息成功
CHECK(t.send("msg-1", kSendReliable) == kResultOK);
CHECK(t.lastMessageNumber() == 1);
// 2. 消息号单调递增
CHECK(t.send("msg-2", kSendReliable) == kResultOK);
CHECK(t.send("msg-3", kSendReliable) == kResultOK);
CHECK(t.lastMessageNumber() == 3);
// 3. 单消息超过 512KiB 上限被拒
std::string big(kMaxMessageSizeSend + 1, 'x');
CHECK(t.send(big, kSendReliable) == kResultInvalidParam);
// 4. 无丢包:一次泵全部按序投递
t.pump(false);
CHECK(!t.hasPending());
CHECK(t.retransmitCount() == 0);
int n = t.receive(out, 16);
CHECK(n == 3);
CHECK(out[0] == "msg-1" && out[1] == "msg-2" && out[2] == "msg-3");
// 5. 取空后无残留
CHECK(t.receive(out, 16) == 0);
// 6. 丢包:可靠消息重传后仍恰好一次按序投递
CHECK(t.send("r-a", kSendReliable) == kResultOK);
CHECK(t.send("r-b", kSendReliable) == kResultOK);
t.pump(true); // 首轮丢包:r-a/r-b 被扣下重传
CHECK(t.retransmitCount() == 2);
CHECK(t.hasPending());
t.pump(false); // 次轮投递
CHECK(!t.hasPending());
n = t.receive(out, 16);
CHECK(n == 2);
CHECK(out[0] == "r-a" && out[1] == "r-b");
// 7. 不可靠消息正常投递
CHECK(t.send("u-ok", kSendUnreliable) == kResultOK);
CHECK(t.receive(out, 16) == 1);
CHECK(out[0] == "u-ok");
// 8. 不可靠消息被标记丢失后不投递
t.markNextUnreliableDrop();
CHECK(t.send("u-lost", kSendUnreliable) == kResultOK);
CHECK(t.receive(out, 16) == 0);
// 9. 断开连接后发送失败
t.disconnect();
CHECK(t.send("x", kSendReliable) == kResultNoConnection);
CHECK(t.send("y", kSendUnreliable) == kResultNoConnection);
// 10. 重连后消息号延续(不重置),可靠性状态机继续
CHECK(t.connect());
CHECK(t.send("after-reconnect", kSendReliable) == kResultOK);
CHECK(t.lastMessageNumber() == 6);
return lab::report("08-3 网络可靠性工程");
}
本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 28/28 通过。
小结
- 可靠消息带 SDK 分配的单调消息号,重传后恰好一次按序投递;应用层用消息号做确认。
- 不可靠消息可能静默丢失,只用于可替换数据;可靠消息会排队,高频状态全发可靠会塞管道。
- 单消息上限 512 KiB,超限返回
InvalidParam;大对象走创意工坊内容管道或切片。 - 断开后发送返回
NoConnection;重连后消息号延续不重置,应用层确认号要能跨重连工作。
阅读导航:上一节:8.2 P2P 会话与消息 · 下一节:9.1 游戏服务器机制 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。