Boost：asio网络编程从同步到异步

在学TCP的时候，写的第一个服务器就是一个echo服务器，那在Boost网络编程中，自然也先写一个echo服务器练练手

同步服务器

客户端

#include <iostream>
#include <boost/asio.hpp>

using namespace boost::asio::ip;
using namespace std;

const int MAX_LENTH = 1024;

int main()
{
	try
	{
		// 创建上下文服务
		boost::asio::io_context ioc;
		// 构造endpoint
		tcp::endpoint remote_ep(address::from_string("127.0.0.1"), 10086);
		// 创建Socket
		tcp::socket sock(ioc);
		boost::system::error_code error = boost::asio::error::host_not_found;
		sock.connect(remote_ep, error);
		if (error)
		{
			cout << "connect fail, code is " << error.value() << " Message: " << error.what() << endl;
			return 0;
		}
		cout << "connect success" << endl;
		cout << "Enter message: ";
		char request[MAX_LENTH];
		cin.getline(request, MAX_LENTH);
		size_t request_length = strlen(request);
		boost::asio::write(sock, boost::asio::buffer(request, request_length));

		char reply[MAX_LENTH];
		size_t reply_length = boost::asio::read(sock, boost::asio::buffer(reply, request_length));
		cout << "Reply is ";
		cout.write(reply, reply_length);
		cout << endl;

	}
	catch(exception& e)
	{
		cerr << e.what() << endl;
	}
	return 0;
}

服务端

服务端这里采用的是一个线程处理一个连接的方式，同时使用一个智能指针集合来保证不被异常释放，主要是通过增加一个引用计数，使得不会在离开作用域后就被销毁

server的作用就是一个接收者，他负责进行连接的获取，并进行对应的分发，通过创建一个一个的线程，然后执行对应的session逻辑，进行对应的回报处理

#include <iostream>
#include <boost/asio.hpp>
#include <set>
#include <memory>

using boost::asio::ip::tcp;
using namespace std;

const int MAX_LENTH = 1024;
typedef shared_ptr<tcp::socket> socket_ptr;
set<shared_ptr<thread>> thread_set;

// 服务器处理客户端的读和写
void session(socket_ptr sock)
{
	try
	{
		for (;;)
		{
			char data[MAX_LENTH];
			memset(data, '\0', MAX_LENTH);
			boost::system::error_code error;
			// 直到读到最长为止，要读到1024字节
			//size_t length = boost::asio::read(sock, boost::asio::buffer(data, MAX_LENTH), error);
			// 部分读取，读多少算多少
			size_t length = sock->read_some(boost::asio::buffer(data, MAX_LENTH), error);
			if (error == boost::asio::error::eof)
			{
				cout << "connection closed" << endl;
				break;
			}
			else if (error)
			{
				throw boost::system::system_error(error);
			}
			cout << "receive from " << sock->remote_endpoint().address().to_string() << endl;
			cout << "receive message is " << data << endl;
			// 将数据传递回去
			boost::asio::write(*sock, boost::asio::buffer(data, MAX_LENTH));
		}
	}
	catch (exception& e)
	{
		cerr << "Exception in thread" << e.what() << endl;
	}
}

void server(boost::asio::io_context& ioc, unsigned short port)
{
	// 专门来接受连接，必须按照传递方式，Acceptor是归属于某个ioc，以及用ipv4的方式进行绑定到端口
	tcp::acceptor a(ioc, tcp::endpoint(tcp::v4(), port));
	for (;;)
	{
		socket_ptr socket(new tcp::socket(ioc));
		a.accept(*socket);
		// 创建线程，做session工作，参数是Socket，等待客户端发数据，回传等工作
		auto t = make_shared<thread>(session, socket);
		thread_set.insert(t);
	}
}

int main()
{
	try
	{
		boost::asio::io_context ioc;
		server(ioc, 10086);
		for (auto& t : thread_set)
		{
			t->join();
		}
	}
	catch (exception& e)
	{
		cerr << "Exception in thread" << e.what() << endl;
	}
	return 0;
}

但是这样同步的结构必然是不可取的，对于小体量的项目还可以接收，但是对于大级别的项目还是要使用异步的方式进行服务器的搭建，因此下面就开始搭建一个异步的服务器

异步服务器(有问题)

首先创建一个会话类

class Session
{
public:
	Session(boost::asio::io_context& ioc)
		: _socket(ioc)
	{}

	tcp::socket& Socket()
	{
		return _socket;
	}

	void Start();

private:
	void handle_read(const boost::system::error_code& error, size_t byte_transferred);

	void handle_write(const boost::system::error_code& error);

private:
	tcp::socket _socket;
	enum { max_length = 1024 };
	char _data[max_length];
};

void Session::Start()
{
	memset(_data, 0, max_length);
	_socket.async_read_some(boost::asio::buffer(_data, max_length),
		bind(&Session::handle_read, this, placeholders::_1, placeholders::_2));
}

// 分批次读取事件回调函数
void Session::handle_read(const boost::system::error_code& error, size_t byte_transferred)
{
	if (!error)
	{
		cout << "server receive data is " << _data << endl;
		boost::asio::async_write(_socket, boost::asio::buffer(_data, byte_transferred),
			bind(&Session::handle_write, this, placeholders::_1));
	}
	else
	{
		cout << "read error" << endl;
		delete this;
	}
}

void Session::handle_write(const boost::system::error_code& error)
{
	if (!error)
	{
		memset(_data, 0, max_length);
		_socket.async_read_some(boost::asio::buffer(_data, max_length),
			bind(&Session::handle_read, this, placeholders::_1, placeholders::_2));
	}
	else
	{
		cout << "write error" << endl;
		delete this;
	}
}

这个会话主要负责的就是对应的echo的功能，将数据接收后再进行对应的发送的过程，收到数据后就进行回调，去将数据发送，同时进行数据发送的回调，进行数据的读取，直到当客户端关闭了连接，此时就会触发一个断开连接的操作，这个操作会被看成是一个读取操作失败，因此就会触发读回调函数的错误

但是这样的设计其实是有问题的，具体我们可以这样想，假设现在有一个内容，需要进行读取事件和写入事件，这是在一个作用域下要同时完成的，假如在进行读事件的时候触发了错误，比如客户端断开连接了，此时就会被捕获到异常，捕获到异常就会直接delete掉当前的这个session，而在作用域内还有一个写事件回调，这个写事件回调也可能会导致一个错误，也被捕获一次异常，进行一个delete函数，那这样就涉及到同一块内存析构两次的情况，这就会造成问题

那为了解决这样的问题，关键就是要对于session的生命周期进行一个合理的管理，因此就需要引入的是一个延长生命周期的操作，这里提供的是一个伪闭包来延长生命周期的操作，这里后续进行演示

为了保证模块的统一性，这里把后续的代码补充一下

class Server
{
public:
	Server(boost::asio::io_context& ioc, short port);

private:
	// 启动一个监听连接的描述符
	void start_accept();
	// 有连接到来后的回调函数
	void handle_accept(Session* new_session, const boost::system::error_code& error);

private:
	boost::asio::io_context& _ioc;
	tcp::acceptor _acceptor;
};

实现如下：

Server::Server(boost::asio::io_context& ioc, short port)
	: _ioc(ioc), _acceptor(ioc, tcp::endpoint(tcp::v4(), port))
{
	// 需要被Acceptor进行捕获
	cout << "port: " << port << endl;
	start_accept();
}

// 启动一个监听连接的描述符
void Server::start_accept()
{
	Session* new_session = new Session(_ioc);
	_acceptor.async_accept(new_session->Socket(), bind(&Server::handle_accept, this, new_session, placeholders::_1));
}

// 有连接到来后的回调函数
void Server::handle_accept(Session* new_session, const boost::system::error_code& error)
{
	if (!error)
	{
		new_session->Start();
	}
	else
	{
		delete new_session;
	}
	start_accept();
}

异步服务器优化

这样的异步服务器实际上是有问题的，问题主要在于前面说的析构的问题，那为了解决这样的问题，可以使用一个引用计数shared_ptr，并且使用一个Session会话进行管理，每一个Session创建一个uuid，作为一个字符串进行管理

那底层是如何进行管理的呢？本质上是维护了一个map，里面存储的是uid和对应的Session的智能指针的对应关系，前面我们说析构函数的问题在于，没有对于Session对象的生命周期进行合理的管理，因此我们就要想办法对于这个生命周期进行适度的延伸

下面理一下这个整体的调用逻辑

下面是代码实现：

#include "Session.h"
#include <iostream>
#include <boost/asio.hpp>

using namespace std;
using boost::asio::ip::tcp;

Session::Session(boost::asio::io_context& ioc, Server* server)
	: _socket(ioc), _server(server)
{
	memset(_data, 0, max_length);
	boost::uuids::uuid a_uuid = boost::uuids::random_generator()();
	_uuid = boost::uuids::to_string(a_uuid);
}

string& Session::GetUuid()
{
	return _uuid;
}

tcp::socket& Session::Socket()
{
	return _socket;
}

void Session::Start()
{
	memset(_data, 0, max_length);
	_socket.async_read_some(boost::asio::buffer(_data, max_length),
		bind(&Session::handle_read, this, placeholders::_1, placeholders::_2, shared_from_this()));
}

// 分批次读取事件回调函数
void Session::handle_read(const boost::system::error_code& error, size_t byte_transferred, shared_ptr<Session> _self_shared)
{
	if (!error)
	{
		cout << "server receive data is " << _data << endl;
		boost::asio::async_write(_socket, boost::asio::buffer(_data, byte_transferred),
			bind(&Session::handle_write, this, placeholders::_1, _self_shared));
	}
	else
	{
		cout << "read error" << endl;
		// 减少引用计数，直接从map中移除即可
		_server->ClearSession(_uuid);
		//delete this;
	}
}

void Session::handle_write(const boost::system::error_code& error, shared_ptr<Session> _self_shared)
{
	if (!error)
	{
		memset(_data, 0, max_length);
		_socket.async_read_some(boost::asio::buffer(_data, max_length),
			bind(&Session::handle_read, this, placeholders::_1, placeholders::_2, _self_shared));
	}
	else
	{
		cout << "write error" << endl;
		_server->ClearSession(_uuid);
		//delete this;
	}
}

Server::Server(boost::asio::io_context& ioc, short port)
	: _ioc(ioc), _acceptor(ioc, tcp::endpoint(tcp::v4(), port))
{
	// 需要被Acceptor进行捕获
	cout << "port: " << port << endl;
	start_accept();
}

void Server::ClearSession(string uuid)
{
	_sessions.erase(uuid);
}


// 启动一个监听连接的描述符
void Server::start_accept()
{
	// 使用智能指针来进行管理
	shared_ptr<Session> new_session = make_shared<Session>(_ioc, this);
	//Session* new_session = new Session(_ioc);
	_acceptor.async_accept(new_session->Socket(), bind(&Server::handle_accept, this, new_session, placeholders::_1));
}

// 有连接到来后的回调函数
void Server::handle_accept(shared_ptr<Session> new_session, const boost::system::error_code& error)
{
	if (!error)
	{
		new_session->Start();
		_sessions.insert(make_pair(new_session->GetUuid(), new_session));
	}
	else
	{
		// delete new_session;
	}
	start_accept();
}