Boost.Asio实战：从零开始构建网络服务 – wiki基地

作者： /

Boost.Asio实战：从零开始构建网络服务

Boost.Asio是一个强大的C++库，为网络编程和低层I/O操作提供了现代化的、可移植的抽象。它简化了异步编程模型，使开发者能够轻松构建高性能、可扩展的网络应用，如服务器、客户端和实时通信系统。本文将深入探讨Boost.Asio，并指导您从零开始构建一个基本的网络服务。

1. Boost.Asio 简介：网络编程的利器

在深入实战之前，让我们先了解一下Boost.Asio的核心概念和优势：

1.1 核心概念

  • I/O 服务 (io_context/io_service): Asio 的核心是 I/O 服务对象。它管理着 I/O 操作、事件循环和资源。在较新版本的Asio中，io_context 替代了旧的 io_service。
  • I/O 对象 (Sockets, Timers 等): 这些对象代表了操作系统资源，例如套接字（sockets）、定时器（timers）等。它们通过 I/O 服务进行管理。
  • 异步操作 (Asynchronous Operations): Asio 的强大之处在于其对异步操作的支持。异步操作允许程序在等待 I/O 完成时继续执行其他任务，而不是阻塞。
  • 回调 (Handlers): 当异步操作完成时（成功或失败），Asio 会调用一个用户提供的回调函数（handler）。
  • Strands: Strands 保证一组回调函数按照特定顺序执行，即使在多线程环境中也是如此。它们提供了一种简单的方式来实现线程安全，而无需复杂的锁机制。

1.2 为什么选择 Boost.Asio?

  • 跨平台: Asio 可以在多种操作系统上运行，包括 Windows、Linux、macOS 等，提供了良好的可移植性。
  • 高性能: Asio 的设计注重效率，通过减少上下文切换和优化内部实现，实现了高性能的网络通信。
  • 异步编程模型: 异步编程模型避免了多线程编程的复杂性，同时又能够充分利用系统资源，提高并发处理能力。
  • 易用性: Asio 提供了清晰、一致的 API，使得开发者可以相对容易地构建复杂的网络应用。
  • 灵活性: Asio 不仅支持 TCP 和 UDP 等常见协议，还支持串口通信、定时器等功能，应用范围广泛。
  • Boost 库的一部分: 作为 Boost 库的一部分，Asio 可以与其他 Boost 组件无缝集成，例如 Boost.Bind、Boost.Function 等。

2. 环境搭建：准备工作

在开始编写代码之前，我们需要确保开发环境已准备就绪：

2.1 安装 Boost

Boost.Asio 是 Boost 库的一部分，因此我们需要先安装 Boost。您可以从 Boost 官方网站 (https://www.boost.org/) 下载最新版本的 Boost 库。

  • Windows:

    • 下载预编译的二进制文件或使用源码编译。
    • 设置环境变量 BOOST_ROOT 指向 Boost 的安装目录。
    • 将 Boost 的库目录添加到您的项目设置中。

  • Linux (以 Ubuntu 为例):
    bash
    sudo apt-get update
    sudo apt-get install libboost-all-dev

  • macOS (使用 Homebrew):
    bash
    brew install boost

2.2 创建项目

您可以使用任何您喜欢的 C++ IDE (如 Visual Studio、CLion、Code::Blocks 等) 或文本编辑器 (如 VS Code、Sublime Text 等) 来创建项目。

2.3 包含头文件

在您的 C++ 源文件中，包含必要的 Asio 头文件：

“`c++

include

include

``
如果使用较旧版本的Boost,可能需要包含#include `等具体头文件

3. 简单的 Echo 服务器：第一个 Asio 程序

让我们从一个经典的 “Echo” 服务器开始。这个服务器将接收客户端发送的数据，并将其原样返回给客户端。

3.1 代码实现

“`c++

include

include

using boost::asio::ip::tcp;

// 处理客户端连接的会话类
class Session : public std::enable_shared_from_this {
public:
Session(tcp::socket socket) : socket_(std::move(socket)) {}

void start() { do_read(); }

private:
void do_read() {
auto self(shared_from_this()); // 保持 Session 对象的生命周期
socket_.async_read_some(boost::asio::buffer(data_, max_length),
this, self {
if (!ec) {
do_write(length);
}
});
}

void do_write(std::size_t length) {
auto self(shared_from_this());
boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
this, self {
if (!ec) {
do_read(); // 继续读取
}
});
}

private:
tcp::socket socket_;
enum { max_length = 1024 };
char data_[max_length];
};

// 服务器类
class Server {
public:
Server(boost::asio::io_context& io_context, short port)
: acceptor_(io_context, tcp::endpoint(tcp::v4(), port))
{
do_accept();
}
private:
void do_accept()
{
acceptor_.async_accept(
this
{
if(!ec)
{
std::make_shared(std::move(socket))->start();
}
do_accept(); //继续接受新的连接
}
);
}
private:
tcp::acceptor acceptor_;
};

int main() {
try {
boost::asio::io_context io_context;
Server server(io_context, 12345); // 监听端口 12345
io_context.run(); // 启动事件循环
} catch (std::exception& e) {
std::cerr << “Exception: ” << e.what() << “\n”;
}
return 0;
}
“`

3.2 代码解析

  • Session 类:

    • Session 类代表一个与客户端的连接会话。
    • socket_ 成员变量存储了与客户端通信的套接字。
    • start() 方法启动会话，开始读取数据。
    • do_read() 方法使用 async_read_some() 异步读取客户端发送的数据。
      • lambda 表达式作为回调函数，在读取操作完成后被调用。
      • shared_from_this() 用于获取 Session 对象的 shared_ptr，确保在异步操作期间对象不会被销毁。
    • do_write() 方法使用 async_write() 异步将数据写回客户端。
      • lambda 表达式作为回调函数，在写入操作完成后被调用。
      • 写入完成后，再次调用 do_read()，开始下一次读取。

  • Server 类:

    • acceptor_ 成员变量是一个 tcp::acceptor 对象，用于监听客户端的连接请求。
    • do_accept()使用async_accept异步的接受客户端连接
      • 当接受了一个新的连接，会创建一个新的Session对象，并启动会话
      • 之后再次调用do_accept()去继续监听新的连接

  • main() 函数:

    • 创建一个 io_context 对象，它是 Asio 的核心。
    • 创建一个 Server 对象，监听指定的端口 (这里是 12345)。
    • 调用 io_context.run() 启动事件循环。事件循环会不断地检查是否有 I/O 事件发生（例如，有新的客户端连接、数据到达等），并调用相应的回调函数。

3.3 编译和运行

  1. 编译: 使用您喜欢的 C++ 编译器（如 g++、clang++）编译代码。确保链接 Boost 库。例如：
    bash
    g++ -std=c++11 -o echo_server echo_server.cpp -lboost_system -pthread

  2. 运行: 运行编译后的可执行文件：
    bash
    ./echo_server

3.4 测试

您可以使用 telnet 或 netcat 等工具来测试 Echo 服务器：

bash
telnet localhost 12345

或者

bash
nc localhost 12345

在终端中输入一些文本，然后按回车键。您应该会看到服务器将您输入的文本原样返回。

4. 添加超时处理：增强健壮性

在实际的网络应用中，超时处理非常重要。如果客户端连接后长时间没有发送数据，或者网络出现问题导致数据传输延迟，服务器应该能够及时地检测到这些情况并进行处理，例如关闭连接，释放资源。

我们可以使用 Asio 的定时器 (timer) 来实现超时处理。

4.1 修改 Session 类

“`c++

include

include

include

using boost::asio::ip::tcp;

class Session : public std::enable_shared_from_this {
public:
Session(boost::asio::io_context& io_context, tcp::socket socket)
: socket_(std::move(socket)),
timer_(io_context, boost::asio::chrono::seconds(30)) // 设置 30 秒超时
{
timer_.async_wait(std::bind(&Session::handle_timeout, this));
}

void start() { do_read(); }

private:
void do_read() {
auto self(shared_from_this());
socket_.async_read_some(boost::asio::buffer(data_, max_length),
this, self {
if (!ec) {
timer_.cancel(); // 取消定时器
do_write(length);
} else if (ec != boost::asio::error::operation_aborted) {
close_connection(); //非主动取消，关闭连接
}
});
}

void do_write(std::size_t length) {
auto self(shared_from_this());
boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
this, self {
if (!ec) {
timer_.expires_at(boost::asio::steady_timer::time_point::max());
//重置超时
timer_.async_wait(std::bind(&Session::handle_timeout, this));
do_read();
} else if (ec != boost::asio::error::operation_aborted) {
close_connection(); //非主动取消，关闭连接
}
});
}

void handle_timeout()
{
    if(timer_.expiry() <= std::chrono::steady_clock::now())
    {
         //时间到，连接超时，关闭
        close_connection();
    }

}

void close_connection()
{
    timer_.cancel();
    socket_.close();
}

private:
tcp::socket socket_;
boost::asio::steady_timer timer_;
enum { max_length = 1024 };
char data_[max_length];
};

class Server {
public:
Server(boost::asio::io_context& io_context, short port)
: acceptor_(io_context, tcp::endpoint(tcp::v4(), port)), io_context_(io_context)
{
do_accept();
}
private:
void do_accept()
{
acceptor_.async_accept(
this
{
if(!ec)
{
std::make_shared(io_context_, std::move(socket))->start();
}
do_accept(); //继续接受新的连接
}
);
}
private:
tcp::acceptor acceptor_;
boost::asio::io_context& io_context_;
};

int main() {
try {
boost::asio::io_context io_context;
Server server(io_context, 12345);
io_context.run();
} catch (std::exception& e) {
std::cerr << “Exception: ” << e.what() << “\n”;
}

return 0;
}
“`

4.2 代码解析

  • timer_ 成员变量: 在 Session 类中添加了一个 boost::asio::steady_timer 类型的成员变量 timer_。
  • 构造函数初始化: 在 Session 类的构造函数中，初始化 timer_，设置超时时间为 30 秒，并使用 async_wait() 启动一个异步等待操作。当定时器到期时，会调用 handle_timeout() 方法。
  • do_read() 和 do_write() 修改:
    • 在 do_read() 中，如果成功读取到数据，则取消定时器 (timer_.cancel())。
    • 在 do_write() 中，如果成功写入数据，则重置定时器到期时间到最大 (timer_.expires_at(boost::asio::steady_timer::time_point::max()))，并重新启动异步等待。
  • handle_timeout:检查定时器是否真的到期，然后关闭连接
  • close_connection:关闭连接前取消定时器

现在，如果客户端连接后 30 秒内没有发送任何数据，服务器将关闭连接。

5. 多线程处理：提高并发性能

到目前为止，我们的 Echo 服务器都是单线程的。这意味着服务器一次只能处理一个客户端连接。为了提高并发性能，我们可以使用多线程来处理多个客户端连接。

Asio 提供了两种主要的多线程处理方式：

  1. 每个连接一个线程: 为每个客户端连接创建一个新的线程。这种方式简单直观，但当连接数非常多时，会创建大量的线程，导致线程切换开销增大，性能下降。
  2. 线程池: 创建一个线程池，将多个连接的任务分配给线程池中的线程来处理。这种方式可以有效地控制线程数量，减少线程切换开销，提高性能。

这里，我们将使用线程池的方式。

5.1 修改 main() 函数

“`c++
int main() {
try {
boost::asio::io_context io_context;
Server server(io_context, 12345);

// 创建线程池 (例如，4 个线程)
std::vector<std::thread> threads;
for (int i = 0; i < 4; ++i) {
  threads.emplace_back([&io_context]() { io_context.run(); });
}

// 等待所有线程结束
for (auto& thread : threads) {
  thread.join();
}

} catch (std::exception& e) {
std::cerr << “Exception: ” << e.what() << “\n”;
}

return 0;
}
“`

5.2 代码解析

  • 线程池创建: 在 main() 函数中，创建了一个 std::vector<std::thread> 来存储线程。然后，使用一个循环创建了多个线程（这里是 4 个）。每个线程都运行 io_context.run()，使它们都参与到 Asio 的事件循环中。
  • 线程等待: 使用 thread.join() 等待所有线程结束。

5.3 注意事项

  • 线程安全: 在多线程环境下，需要特别注意线程安全。Asio 的 io_context 对象本身是线程安全的，但您需要确保您的回调函数（handlers）也是线程安全的。如果回调函数访问了共享资源，需要使用适当的同步机制（如互斥锁、原子操作等）来保护共享资源。
  • Strands: Asio 提供了 strand 对象来简化线程安全。Strand 可以保证一组回调函数按照特定的顺序执行，即使在多线程环境中也是如此。您可以使用 boost::asio::io_context::strand 或 boost::asio::strand 来创建 strand。

6. 总结：构建更复杂的网络服务

通过本文，您已经学习了如何使用 Boost.Asio 构建一个基本的 Echo 服务器，并了解了如何添加超时处理和多线程支持。Asio 的功能远不止于此，您还可以使用它来：

  • 构建客户端: 使用 tcp::socket 和 async_connect() 等方法来连接服务器。
  • 使用 UDP: 使用 udp::socket 和 async_receive_from()、async_send_to() 等方法来进行 UDP 通信。
  • 处理 SSL/TLS: Asio 提供了对 SSL/TLS 的支持，可以构建安全的网络应用。
  • 使用定时器: Asio 的定时器不仅可以用于超时处理，还可以用于执行周期性的任务。
  • 与其他 Boost 库集成: Asio 可以与 Boost.Bind、Boost.Function 等库无缝集成，使您的代码更简洁、更易读。

希望本文能为您打开 Boost.Asio 网络编程的大门。祝您在构建高性能、可扩展的网络服务的道路上一帆风顺！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部