void

异步写操作async_write_someasync_send

异步读操作async_read_someasync_receive

定义一个Session类主要是为了服务端专门为客户端服务创建的管理类

class

public:Session(std::shared_ptrasio::ip::tcp::socket

socket);void

private:std::shared_ptrasio::ip::tcp::socket

_socket;

total_len):_total_len(total_len),_cur_len(0){_msg

new

total_len):_total_len(total_len),_cur_len(0){_msg

new

char[_total_len];}~MsgNode(){delete[]

_msg;}

};其中_msg表示要发送的数据_cur_len表示已经发送的长度而_total_len表示数据的总长度

async_write_some

通过源码可以看出async_write_some需要两个参数。

第一个参数是buffer结构的数据用来放需要发送的数据第二个参数是一个回调函数这个回调函数又有两个参数一个是用来存放错误码的对象另一个是无符号整数(这个无符号整数代表的就是当前具体发送数据的大小)

当调用完async_write_some之后(即一次异步写操作结束之后)系统会调用这个回调函数。

void

Session::WriteCallBackErr(const

ec,

bytes_transferred;this-_socket-async_write_some(boost::asio::buffer(node-_msg

node-_cur_len,

node-_cur_len),std::bind(Session::WriteCallBackErr,

this,

Session::WriteToSocketErr(const

std::string

std::make_sharedMsgNode(buf.c_str(),

buf.size());_socket-async_write_some(boost::asio::buffer(buf.c_str(),

buf.size()),std::bind(Session::WriteCallBackErr,

this,

}在以上代码中先在WriteToSocketErr函数中创建一个消息结点然后调用async_write_some将数据发送出去。

当一次写操作结束之后。

系统会将错误码和已写入数据的长度作为参数给回调函数。

(node-_cur_len

node-_total_len)在回调函数中判断是否已经将数据全部发送出去了如果没有则更新_cur_len,然后继续执行异步发送操作

但是以上代码逻辑中存在一个漏洞。

在异步执行的逻辑中代码调用的顺序是不确定的。

举个例子当需要连续两次发送hello

WriteToSocketErr(HelloWorld);可能会发生第一次进行写入的时候只写入了Hello,这时按照逻辑需要执行回调函数当在回调函数中发现数据并没有发送完全于是再次调用async_write_some想继续写入World但此时第二次调用WriteToSocketErr(HelloWorld);中已经提前一步调用了async_write_some并将数据全部写完然后才轮到第一次发送时的回调函数将剩下的World继续发完。

这最终导致的结果时对方收到的数据为HelloHelloWorldWorld.

为了确保发送顺序的问题可以在Session类中定义一个队列用来管理需要发送的结点和i一个布尔类型变量用来表示当前是否有数据正在被发送(初始化为false)

class

public:Session(std::shared_ptrboost::asio::ip::tcp::socket

socket):_socket(socket),_send_pending(false){}void

WriteCallBack(const

private:std::queuestd::shared_ptrMsgNode

_send_queue;std::shared_ptrasio::ip::tcp::socket

_socket;bool

std::endl;return;}std::shared_ptrMsgNodenode

_send_queue.front();node-_cur_len

bytes_transferred;if

node-_total_len)//还没有发送完{_socket-async_write_some(boost::asio::buffer(node-_msg

node-_cur_len,

bytes_transferred),std::bind(WriteCallBack,

this,

std::placeholders::_2));return;}_send_queue.pop();if

(_send_queue.empty()){_send_pending

false;}else{std::shared_ptrMsgNode

node

_send_queue.front();_socket-async_write_some(boost::asio::buffer(node-_msg,

node-_total_len),std::bind(Session::WriteCallBack,

}void

{_send_queue.push(std::make_sharedMsgNode(buf.c_str(),

buf.size()));if

(_send_pending)//当前有消息正在发{return;}_socket-async_write_some(boost::asio::buffer(buf.c_str(),

buf.size()),std::bind(Session::WriteCallBack,

this,

std::placeholders::_2));_send_pending

true;

}在WriteToSocket函数中先不着急将数据立马发送出去而是将数据节点放入到发送队列中然后判断当前是否有数据正在发送如果有就返回避免冲突没有就直接调用async_write_some在回调函数中永远都是取出队首的结点进行发送如果判断队首的元素数据已经发送完了就pop掉并且检查队列中是否还有需要发送的元素:如果有继续执行发送逻辑如果没有就将_send_pending置为false表示当前已经没有数据正在发送了。

async_send

async_send的作用是直接将所有数据全部发送完代码逻辑也比async_write_some要简单一些

void

Session::WriteAllToSocket(const

std::string

{_send_queue.push(std::make_sharedMsgNode(buf.c_str(),

buf.size()));if

(_send_pending){return;}_socket-async_send(boost::asio::buffer(buf.c_str(),

buf.size()),std::bind(Session::WriteAllCallBck,

this,

std::placeholders::_2));_send_pending

true;

std::endl;return;}_send_queue.pop();if

(_send_queue.empty()){_send_pending

false;}else{std::shared_ptrMsgNode

node

_send_queue.front();_socket-async_send(boost::asio::buffer(node-_msg,

node-_total_len),std::bind(Session::WriteAllCallBck,

this,

async_send和async_write_some不要放在一起使用因为async_send底层还是多次调用的async_write_some。

如果一起使用还是会引发数据冲突的问题

异步读操作

为了准备读操作,需要在Session类中添加数据结点_recv_node和一个布尔变量_recv_pending

class

public:Session(std::shared_ptrboost::asio::ip::tcp::socket

socket):_socket(socket),_send_pending(false),_recv_pending(false){}void

Connect(boost::asio::ip::tcp::endpoint

ep);void

bytes_transferred);private:std::shared_ptrboost::asio::ip::tcp::socket

_send_node;std::queuestd::shared_ptrMsgNode

_send_queue;std::shared_ptrMsgNode

_recv_node;bool

};由于接收的数据在TCP缓冲区里面已经是排好序了的所以并不需要队列来维护顺序

async_read_some

(_recv_pending){return;}_recv_node

std::make_sharedMsgNode(RECVSIZE);_socket-async_read_some(boost::asio::buffer(_recv_node-_msg,

_recv_node-_total_len),std::bind(Session::ReadCallBack,

this,

std::placeholders::_2));_recv_pending

true;

_recv_node-_total_len){_recv_node-_cur_len

bytes_transferred;_socket-async_read_some(boost::asio::buffer(_recv_node-_msg

_recv_node-_cur_len,

_recv_node-_cur_len),std::bind(Session::ReadCallBack,

this,

std::placeholders::_2));return;}_recv_pending

false;

_recv_node-_total_len){_recv_node-_cur_len

bytes_transferred;_socket-async_read_some(boost::asio::buffer(_recv_node-_msg

_recv_node-_cur_len,

_recv_node-_cur_len),std::bind(Session::ReadCallBack,

this,

std::placeholders::_2));return;}_recv_pending

false;

(_recv_pending){return;}_recv_node

std::make_sharedMsgNode(RECVSIZE);_socket-async_receive(boost::asio::buffer(_recv_node-_msg,

_recv_node-_total_len),std::bind(Session::ReadAllCallBack,

this,

std::placeholders::_2));_recv_pending

true;

std::endl;return;}_recv_pending

false;