Skip to content

Latest commit

 

History

History

Async

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
 
 
 
 
 
 
 
 

README.md

Async Server 学习笔记

这个目录包含了一个基于 Boost.Asio 的异步 (Asynchronous) TCP 服务器实现。与同步服务器不同,异步服务器在单线程中通过回调机制处理并发连接,是高性能网络编程的主流模式。

版本说明 (Versions)

为了展示学习过程,本项目分为两个版本:

  1. v1_Simple:

    • 初始版本。
    • 采用"半双工"模式(读-写-读)。
    • 逻辑简单,但存在性能瓶颈和潜在的死锁风险。
    • 适合初学者理解异步回调的基本流程。
  2. v2_FullDuplex:

    • 改进版本 (推荐)。
    • 采用"全双工"模式(读写分离)。
    • 引入发送队列 (std::queue) 解决并发写问题。
    • 引入消息协议 (Header + Body) 解决 TCP 粘包/半包问题。
    • 更加健壮,接近生产环境的写法。
  3. AsyncClient:

    • 配套客户端。
    • 实现了与 v2 服务器兼容的协议(Header + Body)。
    • 同样采用全双工异步模式,支持在主线程输入的同时接收服务器消息。
    • 演示了如何编写线程安全的异步客户端类。

架构对比 (v1 vs v2)

v1_Simple: 半双工与直接发送

v1 版本采用最简单的 "Read -> Handle -> Write" 流程。

sequenceDiagram
    participant Client
    participant Session
    participant Socket

    Note over Session: 1. 等待读取
    Session->>Socket: async_read_some
    Client->>Socket: Send Data
    Socket-->>Session: HandleRead

    Note over Session: 2. 处理并发送
    Session->>Socket: async_write (Echo)
    Socket-->>Session: HandleWrite

    Note over Session: 3. 再次等待读取
    Session->>Socket: async_read_some
Loading

存在的问题:

  1. 半双工阻塞: 必须等 async_write 完成后才能再次调用 async_read。如果发送数据量大或网络慢,服务器将无法及时处理客户端的新请求。
  2. 并发写崩溃: 如果业务逻辑需要在 HandleRead 之外(例如定时器、其他线程)发送数据,可能会导致多个 async_write 同时操作同一个 Socket,引发崩溃。
  3. 粘包问题: 没有定义消息边界,如果客户端发送 "Hello" 和 "World" 很快,服务器可能一次读到 "HelloWorld",导致逻辑错误。

v2_FullDuplex: 全双工与队列机制

v2 版本引入了 发送队列 和 消息协议,实现了真正的全双工通信。

sequenceDiagram
    participant Client
    participant Session
    participant Socket
    participant Queue

    Note over Session: 1. 持续读取 (独立循环)
    Session->>Socket: async_read_some
    Client->>Socket: Send Data
    Socket-->>Session: HandleRead
    Session->>Socket: async_read_some (立即再次调用)

    Note over Session: 2. 异步发送 (独立循环)
    Session->>Queue: Push Msg
    
    alt Queue was Empty
        Session->>Socket: async_write
    else Queue not Empty
        Note right of Queue: 排队等待
    end

    Socket-->>Session: HandleWrite
    Session->>Queue: Pop Msg
    opt Queue has more
        Session->>Socket: async_write
    end
Loading

改进带来的益处:

  1. 全双工通信: 读和写完全分离。即使正在发送大数据,服务器依然能立即响应新的读取请求。
  2. 线程安全与串行化: 通过 std::queue 和 std::mutex,确保同一时刻只有一个 async_write 在执行,无论多少个线程同时调用 Send() 都是安全的。
  3. 解决粘包: 引入 MsgNode 和头部协议(Header Length + Body),配合状态机解析,确保每次都能拿到完整的业务包。
  4. 生命周期管理: MsgNode 独立管理数据内存,避免了异步操作中缓冲区失效的问题。

核心架构解析 (基于 v2_FullDuplex)

1. 核心数据结构:MsgNode

MsgNode 类用于管理消息数据的生命周期,确保在异步操作期间数据有效。

成员变量 类型 说明
_total_len int 消息的总长度。对于发送节点,包含头部+数据;对于接收节点,为数据体长度。
_cur_len int 当前已处理(已发送或已接收)的长度。
_msg char* 实际的数据缓冲区。

2. 会话管理:Session 类

Session 类负责处理单个连接的所有读写操作。

  • 生命周期管理: 继承 std::enable_shared_from_this,利用 shared_from_this() 在异步回调中延长对象生命周期(伪闭包)。
  • 收发分离:
    • 接收: 使用 HandleRead 配合状态机处理粘包/半包。
    • 发送: 使用 _send_queue 配合 HandleWrite 实现串行化发送。

3. 接收逻辑 (HandleRead 状态机)

接收逻辑采用状态机设计,循环处理接收到的数据流,解决 TCP 粘包问题。

graph TD
    Start[HandleRead 回调触发] --> CheckError{"是否有错误?"}
    CheckError -- Yes --> Close[关闭会话]
    CheckError -- No --> Loop[循环处理 bytes_transferred]
    
    Loop --> StateCheck{"_b_head_parsed?"}
    
    %% 状态1:解析头部
    StateCheck -- False (读头部) --> HeadCheck{"接收数据 + 已读头部 < HEAD_LEN?"}
    HeadCheck -- Yes (头部未满) --> CopyHeadPart[拷贝数据到 _recv_head_node]
    CopyHeadPart --> ContinueRead[继续 async_read]
    
    HeadCheck -- No (头部已满) --> ParseHead[拷贝头部剩余部分 & 解析数据长度 data_len]
    ParseHead --> LenCheck{"data_len > MAX_LEN?"}
    LenCheck -- Yes --> Close
    LenCheck -- No --> AllocBody["创建 _recv_msg_node(data_len)"]
    
    AllocBody --> BodyCheck{"剩余数据 < data_len?"}
    BodyCheck -- Yes (体未满) --> CopyBodyPart[拷贝剩余数据到 _recv_msg_node]
    CopyBodyPart --> SetFlag[设 _b_head_parsed = true]
    SetFlag --> ContinueRead
    
    BodyCheck -- No (体已满) --> CopyBodyFull[拷贝 data_len 长度数据]
    CopyBodyFull --> ProcessMsg["处理消息 (Send)"]
    ProcessMsg --> ResetHead[重置 _b_head_parsed = false, 清空 _recv_head_node]
    ResetHead --> LoopEnd{"还有剩余数据?"}
    LoopEnd -- Yes --> Loop
    LoopEnd -- No --> ContinueRead

    %% 状态2:解析包体
    StateCheck -- True (读包体) --> RemainCheck{"接收数据 < 剩余包体长度?"}
    RemainCheck -- Yes (体未满) --> CopyBodyPart2[拷贝数据到 _recv_msg_node]
    CopyBodyPart2 --> ContinueRead
    
    RemainCheck -- No (体已满) --> CopyBodyFull2[拷贝剩余包体长度]
    CopyBodyFull2 --> ProcessMsg2["处理消息 (Send)"]
    ProcessMsg2 --> ResetHead2[重置 _b_head_parsed = false, 清空 _recv_head_node]
    ResetHead2 --> LoopEnd
Loading

4. 发送逻辑 (队列机制)

Boost.Asio 要求同一个 Socket 在同一时间只能有一个 async_write 操作。

  • Send: 加锁 -> 封装 MsgNode -> 入队 -> 若队列原为空则触发 async_write。
  • HandleWrite: 检查错误 -> 弹出队首 -> 若队列不空则继续 async_write。

完整交互流程 (v2)

sequenceDiagram
    participant Main as main()
    participant Server as Server
    participant Acceptor as tcp::acceptor
    participant Session as Session
    participant Socket as tcp::socket
    participant Client as Client (Remote)

    Note over Main, Server: 1. 服务器启动
    Main->>Server: Server(ioc, port)
    Server->>Server: StartAccept()
    Server->>Session: make_shared<Session>()
    Server->>Acceptor: async_accept(Session->Socket)

    Note over Client, Acceptor: 2. 建立连接
    Client->>Acceptor: Connect
    Acceptor-->>Server: HandleAccept(error)
    Server->>Session: Start()
    Server->>Server: _sessions.insert(uuid, session)
    Server->>Server: StartAccept() (Loop)

    Note over Session, Client: 3. 数据接收 (全双工)
    Session->>Socket: async_read_some(buffer)
    Client->>Socket: Send Data (Head + Body)
    Socket-->>Session: HandleRead(bytes)
    
    loop 消息解析 (状态机)
        Session->>Session: 解析头部 (HEAD_LENGTH)
        Session->>Session: 解析包体 (Body Length)
        Session->>Session: 完整消息就绪
        Session->>Session: 业务处理 (Echo)
    end

    Note over Session, Client: 4. 数据发送 (回显)
    Session->>Session: Send(msg)
    Session->>Session: _send_queue.push(MsgNode)
    
    alt 队列为空 (启动发送)
        Session->>Socket: async_write(MsgNode)
    else 队列不为空 (排队)
        Note right of Session: 仅 Push,等待回调触发
    end

    Socket-->>Session: HandleWrite(error)
    Session->>Session: _send_queue.pop()
    
    opt 队列仍有数据
        Session->>Socket: async_write(Next MsgNode)
    end
    
    Note over Session, Client: 5. 断开连接
    Client->>Socket: Close / Error
    Socket-->>Session: HandleRead (Error)
    Session->>Server: ClearSession(uuid)
    Server->>Server: _sessions.erase(uuid)
    Note right of Session: Session 引用计数归零,析构
Loading

常见问题与陷阱 (Troubleshooting)

1. 循环引用与前向声明

  • 问题: Server 和 Session 互相引用导致编译错误。
  • 解决: 头文件中使用 class Server; 前向声明,源文件中包含 #include "Server_demo.h"。

2. 异步写操作的并发问题

  • 问题: 直接连续调用 async_write 会导致 Socket 崩溃。
  • 解决: 使用 std::queue 保证同一时刻只有一个写操作。

3. 粘包与半包

  • 问题: TCP 是流式协议,一次 read 可能读到半个包或多个包。
  • 解决: 定义消息协议(头部长度+包体),使用状态机在 HandleRead 中循环解析。

编译与运行

依赖

  • C++ 编译器 (支持 C++11 及以上,推荐 C++20)
  • Boost 库 (主要使用 Boost.Asio, Boost.System, Boost.UUID)

编译命令 (MinGW 示例)

g++ -o AsyncServer.exe AsyncServer.cpp Server_demo.cpp Session_demo.cpp -lws2_32 -lboost_system