網絡通信第五課 多線程異步服務器

場景
        本例子支持多線程異步處理消息，針對每一個鏈接請求，創建線程處理稍后的指令，CSimpleSession::SessionThreadFunc是線程函數,async_read_some函數設置接收數據的回調函數ContinueRead，一般情況下，read_some函數未必能夠完整的讀取客戶端發送的數據包，當然必須要指定明確的結束標志，雙方必須規定好等接收完畢的時候，必須等待線程返回，因此在析構函數調用m_thread->join函數，等線程函數正常返回之后，關閉連接，如果沒有等待線程返回，就直接關閉連接，會導致async_read_some函數拋出異常，目前暫時沒有什么頭緒

service.h

#ifndef QPIDPUSHMESSAGESERVICE_H
#define QPIDPUSHMESSAGESERVICE_H

#include <iostream>
#include <vector>
#include <fstream>
#include <boost/asio.hpp>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function/function0.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/thread/mutex.hpp>

namespace qpid
{
class CSimpleSession : public boost::enable_shared_from_this<CSimpleSession>
{
public:
CSimpleSession(boost::asio::io_service &io_service) : m_socket(io_service)
{
m_bRunning = true;
PrepareForNextRecv();
}
~CSimpleSession()
{
m_bRunning = false;
m_thread->join();
m_socket.close();
}

void StartThread()
{
static boost::asio::ip::tcp::no_delay option(true);
m_socket.set_option(option);
m_thread.reset(new boost::thread(boost::bind(&CSimpleSession::SessionThreadFunc, this)));
}

void SessionThreadFunc()
{
while (m_bRunning)
{
if (m_bStartSetCallBackRead)
{
m_socket.async_read_some(boost::asio::buffer(m_szRecvBuffer),
boost::bind(&CSimpleSession::ContinueRead, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
m_bStartSetCallBackRead = false;
}
boost::this_thread::sleep_for(boost::chrono::milliseconds(300));
}
m_bRunning = false;
}

boost::asio::ip::tcp::socket &GetSocket()
{
return m_socket;
}

bool GetCurThreadRunningStatus()
{
return m_bRunning;
}

void PrepareForNextRecv()
{
memset(m_szRecvBuffer, 0x00, 10240);
m_strMatch = "";
m_bStartSetCallBackRead = true;
}

private:

void ContinueRead(const boost::system::error_code &error, std::size_t bytes_transferred)
{
if (error)
{
m_bRunning = false;
return;
}

m_strMatch =  m_szRecvBuffer;
int nIndexOfContentLength = m_strMatch.find("Content-Length:", 0);
int indexOfEnd = m_strMatch.find("\r\n\r\n", 0);
if (nIndexOfContentLength  == -1)
{
m_bRunning = false;
return;
}
std::cout << m_strMatch << std::endl;
std::string strContextLen = m_strMatch.substr(nIndexOfContentLength + 15, indexOfEnd - nIndexOfContentLength - 15);
int nContextLen = atoi(strContextLen.c_str());
if (nContextLen < m_strMatch.length())
{
//handle
m_bRunning = false;
return;
}

m_socket.async_read_some(boost::asio::buffer((m_szRecvBuffer)),
boost::bind(&CSimpleSession::ContinueRead, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}

private:
boost::asio::ip::tcp::socket m_socket;
char m_szRecvBuffer[10240];
std::string m_strMatch;
bool m_bStartSetCallBackRead;
bool m_bRunning;
boost::shared_ptr<boost::thread> m_thread;
};

typedef boost::shared_ptr<CSimpleSession> CPtrSession;

class CSimpleServer
{
public:

CSimpleServer(boost::asio::io_service &io_service, boost::asio::ip::tcp::endpoint &endpoint)
:m_ioService(io_service), m_acceptor(io_service, endpoint)
{
CPtrSession newSession(new CSimpleSession(io_service));
m_vecSession.push_back(newSession);
m_acceptor.async_accept(newSession->GetSocket(),
boost::bind(&CSimpleServer::HandleAccept,
this,
newSession,
boost::asio::placeholders::error));
}

void HandleAccept(CPtrSession newSession, const boost::system::error_code &error)
{
if (error)return;

//如果Start函數進行了阻塞，只有處理完當前的連接，才會進行下一步處理連接
newSession->StartThread();
ClearHasEndConnection();
CPtrSession createNewSession(new CSimpleSession(m_ioService));

//當前保存了會話連接，直到連接被釋放，而不是由于createNewSession跳出循環，導致套接字異常

m_vecSession.push_back(createNewSession);
m_acceptor.async_accept(createNewSession->GetSocket(),
boost::bind(&CSimpleServer::HandleAccept,
this,
createNewSession,
boost::asio::placeholders::error));
}

//定時清除結束的連接

void ClearHasEndConnection()
{
std::vector<CPtrSession>::iterator iter;
iter = m_vecSession.begin();
std::size_t count = m_vecSession.size();
std::cout << "session count:" << count << std::endl;
while (iter != m_vecSession.end())
{
if (!(*iter)->GetCurThreadRunningStatus())
{
iter->reset();
m_vecSession.erase(iter);
break;
}
iter++;
}
}

void run()
{
m_ioService.run();
}

private:
boost::asio::io_service &m_ioService;
std::vector<CPtrSession> m_vecSession;
boost::asio::ip::tcp::acceptor m_acceptor;
};

void StartListenThread();

int StartListenService();
}

#endif

service.cpp

#include <boost/thread/thread.hpp>
#include "service.h"

void qpid::StartListenThread()
{
boost::asio::io_service ioService;
boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::address::from_string("192.168.0.34"), 7003);

qpid::CSimpleServer s(ioService, endpoint);
s.run();
}

int qpid::StartListenService()
{
boost::thread serviceThread(&StartListenThread);
serviceThread.detach();
return 0;
}

說明
這里跟之前的asio 異步服務器是有很大的區別
1）套接字可以不用關閉，其次也不需要擔心線程的返回問題
2）不再需要保存請求處理的實例，自然也就沒有管理所有實例的必要性，至于什么時候退出，服務器的接收線程不需要考慮
錯誤提醒：
在實際的應用環境中，在讀數據m_socket.read_some(boost::asio::buffer(szRecvBuf), ec)的時候，會產生套接字錯誤，返回10035，代表含義是在一個非套接字上嘗試了一個操作。
出現原因分析：
當線程分離的時候，accept函數開始等待下一個請求，createNewSession由于是智能指針，跳出了函數，開始調用析構函數進行對象的清理，這個時候m_socket已經被清理掉了，很多類的成員變量已經無法被使用了，m_vecThreadInstance.push_back(createNewSession);卻能夠保存對象的實例，不至于馬上調用析構函數，如果調用該函數的話，就必須自己定時清理已經服務完畢的對象