C++ WebSocket服务器实战：从协议解析到高并发架构设计

1. 项目概述与核心价值最近在整理自己的项目仓库翻到了一个几年前写的C WebSocket五子棋项目。当时WebSocket技术刚兴起不久想用它来练手顺便把C的网络编程、多线程和游戏逻辑都串起来。这个项目本质上是一个C后端服务器它通过WebSocket协议与多个网页前端建立全双工通信实现一个支持多人在线对战的网页版五子棋游戏。你不需要安装任何客户端打开浏览器就能和好友实时对战所有落子、胜负判定、聊天都在网页上完成。为什么用C写WebSocket服务器很多人第一反应可能是用Node.js或者Go它们写起来确实快。但C的优势在于极致的性能和可控性。对于一个实时对战游戏服务器的响应延迟和并发处理能力至关重要。C允许你从内存管理、线程调度到网络I/O进行精细控制尤其是在处理成千上万个并发连接时其资源利用效率是很多带GC的语言难以比拟的。这个项目麻雀虽小但涉及了非阻塞I/O、多线程并发、自定义协议设计、游戏状态同步等多个后端开发的核心难点非常适合用来深入理解网络服务的底层原理。整个项目我会分上下两篇来拆解。上篇也就是本篇将聚焦于服务器的基础架构搭建包括WebSocket协议的握手与帧解析、基于事件驱动的网络模型设计以及多用户连接的管理。下篇则会深入游戏房间的逻辑、五子棋的胜负判定算法以及前后端数据协议的详细设计。无论你是想学习C网络编程还是对如何从零构建一个实时交互服务感兴趣相信这个项目都能给你带来不少启发。2. 技术选型与整体架构设计在动手写代码之前技术栈的选型和整体架构的规划至关重要。这决定了项目的可行性、开发效率以及未来的可维护性。2.1 核心组件选型解析网络库原生Socket vs. 第三方库为什么不直接用原生Socket API原生Berkeley Socketsocket,bind,listen,accept,send/recv是基础但实现一个完整的、高性能的WebSocket服务器需要处理大量细节非阻塞I/O、事件多路复用如epoll/kqueue、协议解析、连接管理等。从零实现这些工程量巨大且容易出错。为什么选择Boost.Asio我最终选择了Boost.Asio。它是一个跨平台的C网络编程库完美封装了不同操作系统下的异步I/O模型如Linux的epoll Windows的IOCP。它提供了强大的异步操作支持让我们可以用回调或C11以后的协程的方式编写高性能网络程序而无需陷入复杂的多线程同步陷阱。对于学习而言它比原生API更友好对于项目而言它提供了工业级的稳定性和性能。WebSocket协议实现手动实现 vs. 使用库WebSocket协议RFC 6455包括握手HTTP Upgrade和数据帧格式。手动实现握手和帧解析是一个很好的学习过程能让你透彻理解协议。本项目上篇将带领你手动实现这部分核心逻辑。但在生产环境中可以考虑使用更成熟的库如websocketpp基于Boost.Asio或uWebSockets。JSON序列化前后端通信需要一种轻量级的数据交换格式。JSON是Web领域的绝对标准。C中我选用nlohmann/json这个单头文件库。它语法直观几乎和动态语言操作JSON一样方便极大提升了开发效率。编译与构建CMake用于管理跨平台的构建过程。它可以方便地查找Boost等依赖库生成适用于不同IDE如VS Code, CLion, Visual Studio的项目文件。前端技术前端相对简单就是一个网页。使用HTML5 Canvas绘制棋盘和棋子JavaScript处理用户交互点击落子并通过WebSocket API与后端通信。前端代码不是本系列的重点但会提供完整可用的示例。2.2 服务器端架构设计整个服务器的核心是一个事件驱动的异步模型。这里我采用一个经典的“单线程事件循环 线程池处理业务逻辑”的架构这也是很多高性能服务器的常见模式。主线程 (Main Thread) | |--- 初始化加载配置创建监听Socket启动I/O上下文io_context | |--- 事件循环 (io_context.run()) | | | |--- 异步接受新连接 (async_accept) | |--- 异步读取数据 (async_read) | |--- 异步写入数据 (async_write) | |--- 所有网络I/O事件在此线程被触发并调用对应的回调函数 | |--- 连接管理器 (ConnectionManager) | |--- 存储所有活跃的客户端连接shared_ptrClientSession | |--- 负责连接的创建、删除和广播消息 | |--- 业务逻辑线程池 (Thread Pool) | |--- 主线程通过消息队列将解码后的WebSocket消息如“落子请求”分发给线程池 |--- 线程池中的工作线程执行耗时的业务逻辑游戏规则判定、数据库操作等 |--- 处理完成后将响应消息投递回主线程的发送队列由主线程异步写出这个架构的优势在于高并发单线程处理所有网络I/O避免了为每个连接创建线程的巨大开销C10K问题。响应迅速I/O线程不被阻塞可以快速响应新连接和网络事件。逻辑清晰将耗时的业务计算与敏感的网络I/O分离业务逻辑的阻塞不会影响其他连接的通信。注意这个架构中所有对ConnectionManager连接管理器的访问都必须考虑线程安全因为主线程I/O线程和工作线程可能同时操作它。通常需要使用互斥锁std::mutex来保护内部数据结构。3. WebSocket协议核心握手与数据帧解析要让浏览器和我们的C服务器对话第一步就是完成WebSocket握手之后所有的通信都基于WebSocket数据帧。3.1 WebSocket握手实现详解握手过程本质上是一个特殊的HTTP请求Upgrade请求。服务器需要验证请求并返回正确的响应。1. 客户端握手请求浏览器发起请求的头部关键字段如下GET /chat HTTP/1.1 Host: server.example.com Upgrade: websocket Connection: Upgrade Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ Sec-WebSocket-Version: 13Upgrade: websocket和Connection: Upgrade表明希望升级协议。Sec-WebSocket-Key是一个Base64编码的随机字符串由浏览器生成。Sec-WebSocket-Version: 13表示使用RFC 6455版本13协议。2. 服务器握手响应服务器必须验证Sec-WebSocket-Key并生成Sec-WebSocket-Accept作为响应。算法是固定的将客户端传来的Sec-WebSocket-Key例如dGhlIHNhbXBsZSBub25jZQ与固定的GUID字符串258EAFA5-E914-47DA-95CA-C5AB0DC85B11拼接。对拼接后的字符串进行SHA-1哈希计算。将哈希结果进行Base64编码得到Sec-WebSocket-Accept。响应头如下HTTP/1.1 101 Switching Protocols Upgrade: websocket Connection: Upgrade Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbKxOo3. C代码实现关键片段#include boost/asio.hpp #include string #include openssl/sha.h // 用于SHA-1计算 #include boost/archive/iterators/base64_from_binary.hpp #include boost/archive/iterators/transform_width.hpp std::string generate_websocket_accept_key(const std::string client_key) { const std::string magic_guid 258EAFA5-E914-47DA-95CA-C5AB0DC85B11; std::string combined client_key magic_guid; unsigned char hash[SHA_DIGEST_LENGTH]; // SHA-1结果为20字节 SHA1(reinterpret_castconst unsigned char*(combined.c_str()), combined.size(), hash); // 将20字节的hash进行Base64编码 using namespace boost::archive::iterators; using It base64_from_binarytransform_widthconst unsigned char*, 6, 8; auto base64_str std::string(It(hash), It(hash SHA_DIGEST_LENGTH)); // Base64编码可能不足4的倍数需要补‘’ return base64_str.append((3 - (SHA_DIGEST_LENGTH % 3)) % 3, ); } // 在async_read回调函数中读取到完整的HTTP请求头后 void handle_handshake(boost::asio::ip::tcp::socket socket, const std::string request_header) { // 1. 解析请求头提取 Sec-WebSocket-Key std::string client_key; // ... (简单的字符串查找解析这里省略) // 例如: 找到 Sec-WebSocket-Key: 后面的值 // 2. 生成 Accept Key std::string accept_key generate_websocket_accept_key(client_key); // 3. 构造响应头 std::string response HTTP/1.1 101 Switching Protocols\r\n Upgrade: websocket\r\n Connection: Upgrade\r\n Sec-WebSocket-Accept: accept_key \r\n\r\n; // 注意最后有两个\r\n // 4. 异步发送响应 boost::asio::async_write(socket, boost::asio::buffer(response), [socket, this](boost::system::error_code ec, std::size_t /*length*/) { if (!ec) { // 握手成功将连接状态标记为已建立开始监听WebSocket数据帧 start_read_websocket_frame(socket); } else { // 错误处理关闭连接 socket.close(); } }); }实操心得解析HTTP头部时要特别注意换行符是\r\n。一个健壮的解析器应该能处理头部的各种情况如多余空格、大小写。在练手项目中可以简化处理但要知道工业级库如Boost.Beast会做得更完善。3.2 WebSocket数据帧格式解析握手成功后后续通信的数据都被包装在WebSocket帧Frame中。帧格式是协议的核心必须精确解析。一个WebSocket帧的二进制布局如下来自RFC 64550 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 -------------------------------------------------------- |F|R|R|R| opcode|M| Payload len | Extended payload length | |I|S|S|S| (4) |A| (7) | (16/64) | |N|V|V|V| |S| | (if payload len126/127) | | |1|2|3| |K| | | ------------------------- - - - - - - - - - - - - - - - | Extended payload length continued, if payload len 127 | - - - - - - - - - - - - - - - ------------------------------- | |Masking-key, if MASK set to 1 | -------------------------------------------------------------- | Masking-key (continued) | Payload Data | -------------------------------- - - - - - - - - - - - - - - - : Payload Data continued ... : - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | Payload Data continued ... | ---------------------------------------------------------------关键字段解读与解析步骤第一个字节FIN(1 bit): 是否为消息的最后一帧。一个消息可能分多个帧发送。RSV1, RSV2, RSV3(各1 bit): 扩展用必须为0除非协商了扩展。Opcode(4 bits): 帧类型。0x0: 连续帧 (Continuation)0x1: 文本帧 (Text)0x2: 二进制帧 (Binary)0x8: 连接关闭 (Close)0x9: Ping (心跳检测)0xA: Pong (心跳响应)其他为保留。第二个字节MASK(1 bit): 负载数据是否被掩码Mask处理。从客户端发往服务器的帧此位必须为1即必须掩码。服务器发往客户端的帧此位必须为0。这是安全规范。Payload len(7 bits): 负载数据长度。如果值在 0-125 之间它就是实际长度。如果是 126则后面2个字节16位无符号整数表示长度。如果是 127则后面8个字节64位无符号整数表示长度。掩码键Masking-key如果MASK位为1则接下来的4个字节是掩码键。负载数据Payload Data实际的应用数据。如果存在掩码键需要用这4个字节的掩码键对负载数据进行循环异或XOR解码才能得到原始数据。C解析函数核心逻辑struct WebSocketFrame { bool fin; uint8_t opcode; bool mask; uint64_t payload_length; uint8_t masking_key[4]; std::vectoruint8_t payload_data; }; bool parse_websocket_frame(const std::vectoruint8_t data, WebSocketFrame frame) { if (data.size() 2) return false; // 至少需要2字节头部 const uint8_t* buffer data.data(); size_t index 0; // 解析第一个字节 frame.fin (buffer[index] 0x80) ! 0; frame.opcode buffer[index] 0x0F; index; // 解析第二个字节 frame.mask (buffer[index] 0x80) ! 0; uint64_t payload_len buffer[index] 0x7F; index; // 处理扩展长度 if (payload_len 126) { if (index 2 data.size()) return false; payload_len (static_castuint64_t(buffer[index]) 8) | buffer[index 1]; index 2; } else if (payload_len 127) { if (index 8 data.size()) return false; // 注意网络字节序大端转换这里简化处理假设运行在x86小端机器上 // 生产环境应使用ntohll等函数 payload_len 0; for (int i 0; i 8; i) { payload_len (payload_len 8) | buffer[index i]; } index 8; } frame.payload_length payload_len; // 读取掩码键 if (frame.mask) { if (index 4 data.size()) return false; std::memcpy(frame.masking_key, buffer index, 4); index 4; } // 检查是否有足够的负载数据 if (index payload_len data.size()) return false; // 读取并解码负载数据 frame.payload_data.assign(buffer index, buffer index payload_len); if (frame.mask) { for (size_t i 0; i frame.payload_data.size(); i) { frame.payload_data[i] ^ frame.masking_key[i % 4]; } } return true; }构造发送帧的函数服务器到客户端无需掩码std::vectoruint8_t create_websocket_text_frame(const std::string text) { std::vectoruint8_t frame; // 第一个字节: FIN1, RSV0, Opcode0x1 (文本帧) frame.push_back(0x81); // 第二个字节: MASK0, 计算负载长度 size_t payload_len text.size(); if (payload_len 125) { frame.push_back(static_castuint8_t(payload_len)); } else if (payload_len 65535) { frame.push_back(126); frame.push_back(static_castuint8_t((payload_len 8) 0xFF)); frame.push_back(static_castuint8_t(payload_len 0xFF)); } else { frame.push_back(127); // 写入8字节长度大端序 for (int i 7; i 0; --i) { frame.push_back(static_castuint8_t((payload_len (i * 8)) 0xFF)); } } // 追加负载数据文本 frame.insert(frame.end(), text.begin(), text.end()); return frame; }注意事项实际网络读取是流式的TCP可能会把多个帧粘在一起也可能把一个帧拆开送达。因此我们的async_read回调函数中需要维护一个缓冲区并实现一个状态机不断尝试从缓冲区中解析出完整的帧直到缓冲区为空或解析失败。这是实现中的一个关键细节。4. 服务器核心实现连接管理与事件循环有了协议解析的基础我们就可以构建服务器的核心了。这里我们实现ConnectionManager连接管理器和ClientSession客户端会话。4.1 ClientSession封装单个连接ClientSession类代表一个WebSocket客户端连接。它持有socket管理该连接的生命周期处理数据的收发和解析。class ClientSession : public std::enable_shared_from_thisClientSession { public: using pointer std::shared_ptrClientSession; static pointer create(boost::asio::io_context io_context) { return pointer(new ClientSession(io_context)); } boost::asio::ip::tcp::socket socket() { return socket_; } void start() { // 开始异步读取HTTP握手请求 do_read_handshake(); } void deliver(const std::string message) { // 将消息放入发送队列并触发异步写操作 bool write_in_progress !write_msgs_.empty(); write_msgs_.push_back(message); if (!write_in_progress) { do_write(); } } private: ClientSession(boost::asio::io_context io_context) : socket_(io_context) {} void do_read_handshake() { auto self(shared_from_this()); boost::asio::async_read_until(socket_, streambuf_, \r\n\r\n, [this, self](boost::system::error_code ec, std::size_t /*length*/) { if (!ec) { std::istream is(streambuf_); std::string request_header(std::istreambuf_iteratorchar(is), {}); if (handle_handshake(request_header)) { // 握手成功开始读取WebSocket帧 do_read_frame(); } else { // 握手失败关闭连接 socket_.close(); } } else { socket_.close(); } }); } void do_read_frame() { auto self(shared_from_this()); // 异步读取至少2个字节帧头 boost::asio::async_read(socket_, boost::asio::buffer(read_buffer_, 2), [this, self](boost::system::error_code ec, std::size_t length) { if (!ec) { // 解析基本头部获取负载长度和掩码信息 // ... 调用 parse_websocket_frame_header // 根据负载长度继续异步读取剩余部分掩码键负载数据 // 完整帧读取后进行解码处理业务如JSON解析然后继续读取下一帧 do_read_frame(); // 循环读取 } else { socket_.close(); // 通知ConnectionManager移除自己 } }); } void do_write() { auto self(shared_from_this()); // 取出发送队列第一条消息构造WebSocket帧 std::string msg write_msgs_.front(); std::vectoruint8_t frame create_websocket_text_frame(msg); boost::asio::async_write(socket_, boost::asio::buffer(frame.data(), frame.size()), [this, self](boost::system::error_code ec, std::size_t /*length*/) { if (!ec) { write_msgs_.pop_front(); if (!write_msgs_.empty()) { do_write(); // 继续发送下一条 } } else { socket_.close(); } }); } boost::asio::ip::tcp::socket socket_; boost::asio::streambuf streambuf_; // 用于握手阶段的HTTP头读取 std::arrayuint8_t, 8192 read_buffer_; // 用于读取WebSocket帧 std::dequestd::string write_msgs_; // 发送消息队列 // ... 其他状态如用户ID、所在房间等 };4.2 ConnectionManager管理所有活跃连接ConnectionManager负责创建、跟踪和销毁所有ClientSession对象。它通常被设计为单例或由主类持有。class ConnectionManager { public: ConnectionManager() default; void start(ClientSession::pointer session) { std::lock_guardstd::mutex lock(connections_mutex_); sessions_.insert(session); session-start(); std::cout 新连接加入当前连接数: sessions_.size() std::endl; } void stop(ClientSession::pointer session) { std::lock_guardstd::mutex lock(connections_mutex_); sessions_.erase(session); std::cout 连接断开当前连接数: sessions_.size() std::endl; } void stop_all() { std::lock_guardstd::mutex lock(connections_mutex_); for (auto session : sessions_) { session-stop(); // 需要在ClientSession中实现stop方法关闭socket } sessions_.clear(); } // 广播消息给所有连接例如系统公告 void broadcast(const std::string message) { std::lock_guardstd::mutex lock(connections_mutex_); for (auto session : sessions_) { session-deliver(message); } } private: std::setClientSession::pointer sessions_; std::mutex connections_mutex_; // 保护sessions_的线程安全 };4.3 主服务器类与事件循环GameServer类将一切串联起来初始化监听、接受连接、启动事件循环。class GameServer { public: GameServer(boost::asio::io_context io_context, short port) : io_context_(io_context), acceptor_(io_context, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)) { do_accept(); } private: void do_accept() { acceptor_.async_accept( [this](boost::system::error_code ec, boost::asio::ip::tcp::socket socket) { if (!ec) { // 创建新的会话并由连接管理器管理 auto session ClientSession::create(io_context_); // 将已连接的socket移动给sessionC11移动语义高效 session-socket() std::move(socket); connection_manager_.start(session); } else { std::cerr Accept error: ec.message() std::endl; } // 继续接受下一个连接 do_accept(); }); } boost::asio::io_context io_context_; boost::asio::ip::tcp::acceptor acceptor_; ConnectionManager connection_manager_; }; // main.cpp int main() { try { boost::asio::io_context io_context; GameServer server(io_context, 9000); // 监听9000端口 std::cout 五子棋服务器启动在端口 9000... std::endl; io_context.run(); // 启动事件循环阻塞在此 } catch (std::exception e) { std::cerr 异常: e.what() std::endl; } return 0; }io_context.run()是事件循环的核心。它会持续运行处理所有已注册的异步操作如async_accept,async_read,async_write的回调。当没有更多异步操作需要处理时run()才会返回。5. 多线程优化与消息队列单线程的io_context虽然能处理高并发I/O但所有业务逻辑如五子棋胜负判定也在同一个线程执行的话一旦某个计算阻塞整个服务器的响应都会受影响。因此引入线程池来处理业务逻辑是必要的。5.1 构建简单的线程池与任务队列我们可以实现一个简单的线程池主线程I/O线程将解码后的客户端消息包装成任务投递到任务队列由工作线程取出执行。class ThreadPool { public: using Task std::functionvoid(); ThreadPool(size_t num_threads) : stop_(false) { for (size_t i 0; i num_threads; i) { workers_.emplace_back([this] { for (;;) { Task task; { std::unique_lockstd::mutex lock(queue_mutex_); condition_.wait(lock, [this] { return stop_ || !tasks_.empty(); }); if (stop_ tasks_.empty()) return; task std::move(tasks_.front()); tasks_.pop(); } task(); // 执行业务逻辑 } }); } } templateclass F void enqueue(F f) { { std::lock_guardstd::mutex lock(queue_mutex_); tasks_.emplace(std::forwardF(f)); } condition_.notify_one(); } ~ThreadPool() { { std::lock_guardstd::mutex lock(queue_mutex_); stop_ true; } condition_.notify_all(); for (std::thread worker : workers_) { worker.join(); } } private: std::vectorstd::thread workers_; std::queueTask tasks_; std::mutex queue_mutex_; std::condition_variable condition_; bool stop_; };5.2 I/O线程与工作线程的协作在ClientSession::do_read_frame中当完整解析出一个WebSocket文本帧后// 假设解析出的文本消息是json_str std::string json_str decode_websocket_payload(frame); // 将业务处理交给线程池 thread_pool.enqueue([this, self, json_str]() { // 1. 解析JSON得到命令和参数 nlohmann::json j nlohmann::json::parse(json_str); std::string command j[cmd]; // 2. 处理业务逻辑例如处理落子、创建房间、聊天 nlohmann::json response handle_game_command(command, j); // 3. 将响应消息投递回I/O线程进行发送 // 注意这里需要将response序列化成字符串 std::string response_str response.dump(); // 我们需要一种线程安全的方式让I/O线程来执行deliver // 一种常见做法是使用io_context.post将任务派发回I/O线程 io_context_.post([this, self, response_str]() { this-deliver(response_str); }); });关键点boost::asio::io_context::post()函数可以将一个函数对象安全地投递到io_context所在线程即主I/O线程中执行。这保证了deliver操作涉及socket写总是在I/O线程中执行避免了多线程同时操作同一个socket导致的竞态条件。6. 基础通信测试与常见问题排查在实现上述核心模块后我们需要进行测试确保服务器能正常处理连接和基础消息。6.1 使用简单网页客户端进行测试创建一个简单的test.html使用JavaScript的WebSocket API进行连接测试。!DOCTYPE html html body button onclickconnect()连接服务器/button button onclicksendPing()发送Ping/button button onclickcloseConn()关闭连接/button div idoutput/div script let ws null; function connect() { ws new WebSocket(ws://localhost:9000); ws.onopen function() { log(连接已打开); }; ws.onmessage function(evt) { log(收到消息: evt.data); }; ws.onclose function() { log(连接已关闭); }; ws.onerror function(err) { log(错误: err); }; } function sendPing() { if (ws ws.readyState WebSocket.OPEN) { ws.send(JSON.stringify({cmd: ping, timestamp: Date.now()})); } } function closeConn() { if (ws) ws.close(); } function log(msg) { document.getElementById(output).innerHTML msg br; } /script /body /html6.2 常见问题与调试技巧实录在开发过程中我遇到了不少坑这里记录下最典型的几个问题1握手失败浏览器提示“WebSocket connection to ‘ws://…‘ failed”。排查步骤检查服务器端口是否监听使用netstat -an | grep 9000Linux或netstat -ano | findstr 9000Windows查看端口状态。检查防火墙确保服务器防火墙放行了9000端口。抓包分析使用Wireshark或tcpdump抓取本地回环localhost的流量查看TCP三次握手是否成功以及HTTP Upgrade请求和响应是否完全符合RFC 6455标准。这是最有效的方法。核对响应头最常见的错误是Sec-WebSocket-Accept计算错误或者响应头末尾缺少两个\r\n。仔细对照RFC检查你的响应字符串。我的踩坑记录最初我计算Accept Key时直接对拼接字符串做MD5了结果一直失败。后来仔细阅读RFC才发现必须用SHA-1。问题2能连接但收不到消息或消息乱码。排查步骤检查掩码Mask处理务必记住客户端发来的帧必须解码异或服务器发出的帧不能加掩码。这是最容易出错的地方。在解析帧后和构造帧前打印出Mask位和Payload Length进行核对。检查负载长度解析当长度值为126或127时后续的长度字节是网络字节序大端序。在x86/x64小端机器上直接内存拷贝读取会导致长度值错误。需要使用ntohs或ntohl等函数转换或者手动移位计算。检查粘包/拆包处理你的帧解析器是否能够处理一个TCP包包含多个WebSocket帧或者一个WebSocket帧被拆到多个TCP包的情况确保你的async_read是循环的并且缓冲区管理正确。调试技巧在do_read_frame和do_write函数中将收发的原始字节以十六进制形式打印到日志中。与标准的WebSocket帧格式逐字节对比很容易定位问题。问题3多用户同时连接时服务器崩溃或连接异常断开。排查步骤检查线程安全ConnectionManager的sessions_集合是否被多个线程同时修改务必在所有访问它的地方加锁std::mutex。检查shared_ptr的生命周期在异步回调中是否使用了shared_from_this()来保持ClientSession对象的生命期防止其在回调执行前被销毁这是Boost.Asio异步编程的常见模式。检查io_context的线程安全io_context本身不是线程安全的。确保所有async_系列操作async_read,async_write,async_accept的发起和完成处理都在同一个线程即调用io_context.run()的线程中或者使用io_context::strand来同步。业务线程通过io_context.post()投递任务回I/O线程是安全的。性能提示锁的粒度要细。例如ConnectionManager的广播函数broadcast会遍历所有session并调用deliver。如果deliver内部也有锁且操作耗时可能会造成锁竞争。可以考虑复制一份session列表在锁保护下然后遍历副本进行发送减少锁持有时间。至此我们已经完成了C WebSocket五子棋服务器的上篇内容构建了一个支持多用户连接、基于事件驱动、并初步引入线程池处理业务的高性能服务器骨架。它已经能够处理WebSocket协议的握手、帧的解析与组装以及连接的生命周期管理。在下篇中我们将在此基础上实现具体的游戏业务逻辑房间管理、五子棋规则判定以及更复杂的客户端-服务器通信协议。