一个心跳保活类的设计
心跳在很多的服务器程序中应用很多，作为一种轮询的方案，效率可能没有基于中断的高，但是这种方案非常稳定，因此也被大量采用，心跳说白了就是不断向对方发送数据包，如果对方在确定时间回复就说明对方存活，反之对方已死，在稳定的同时也会造成很多误判，因为如果一旦对方由于一些别的工作耽误了回复心跳，那么这端就会认为对方已经断开从而进行善后处理，这显然是一种误判，解决方案有两种，一种就是在有正常数据收发时不再发送心跳包，试想一下远端服务器为何会耽误回复心跳，就是由于有正常请求要处理，反过来此时发送心跳是没有用的，只会增加服务器的负担，如果服务器断开，那么正常的数据回复就会表现出来；另外一种方式就是将心跳包发送到一个独立的端口，在服务器为该端口启动一个线程专门负责回复心跳包，尽量不让心跳包和其他的数据揉在一起。
我们的系统是这样的，每个端口在服务器开一个线程，所有发往该端口的数据在该线程串行处理，一个端口的每个socket相当于一个通道负责处理一些特殊的命令，起初的想法是将心跳包发往一个8003端口，所有的端口共享一个vector，所有端口从客户端接受的命令都放到这一个vector中，然后由各个端口的处理线程从vector中取出自己负责的命令然后处理，这样看来这个vector就是一个瓶颈，就像一个沙漏一样，这种设计很不合理，当我发现其不合理之处时，我告诉项目经理，我说心跳包发给了服务器的8003端口这没有错，但是如果服务器的vector中在接收到该心跳之前已经排入了一个命令，而这个命令的处理是很耗时的，那怎么办，它很可能会耽误心跳包的回复，经理笑着说，没有问题，客户端做了同步，一个命令发出没有接到回复之前是不让发送第二个命令，我愣了一下，回笑，all right，不错，但是一个客户端做好了自己的同步，它会和别的客户端同样请求服务器8003端口的客户端同步吗？简单说，客户1发送往服务器8003端口的耗时命令可能会影响客户2的心跳包回复，这就是问题！
一个起初的设计缺陷最终导致了一个bug，大改已经不可能了，于是我的想法被采纳了，那就是分离心跳请求，在服务器单开一个8000端口专门负责心跳包处理，虽然服务器的vector这个瓶颈仍然存在，但是不管怎样心跳回复是很迅速的，而且服务器负责8000端口的是一个线程，在负载不是变态大的情况下是可以应付的，我们只能这样改了，这说明设计缺陷可能会导致项目的失败，然而我们不能失败，因为我们做的不是项目，而是产品。我们产品的架构大概就是监控中心客户端维护一个网站镜像列表，网站镜像表现为一个或多个目录，因此每一个目录实际上相当于一个客户端，每个客户端向服务器发送心跳包以确认服务器存活，如果服务器宕机了，那么心跳包仍然被发送，直到心跳包有回复之后，程序逻辑将采取进一步的动作，详细流程没有必要深究，这里主要了解一个目录就是一个客户端就可以了，现在看看服务器，服务器可以有多个，也就是说监控中心的网站镜像可以是多个服务器的镜像，理所当然的设计就是每一个目录绑定一个心跳类，但是问题是，如果有多个网站镜像是同一台服务器的网站镜像，那么多个心跳包将发往一个服务器，这是没有意义的，因此要处理好共享。
我的想法是维护一个容器，每当初始化一个目录的心跳类时先检查容器中是否存在心跳类的IP地址和端口和本次初始化的心跳类的IP地址和端口一致，如果没有找到就把该心跳类放到该容器然后返回NULL，反之如果找到就返回这个找到的心跳类，处理程序检测返回值，如果返回为NULL，那么就使用这个刚刚初始化的心跳类，如果返回不为NULL，将使用返回的心跳类同时释放刚刚初始化的心跳类。问题又来了，这样的话就需要维护一个全局的容器，这样只能使本来就已经很乱的代码更加乱，于是解决办法就是将这个容器设置为static的类型放到心跳类内部，由心跳类自己管理。现在考虑一下释放操作，如果用户删除了网站，绝对不能将心跳类一并停止并析构，因为可能有别的目录在共享这一个心跳类，于是需要在这个心跳类中维持一个计数器，删除的时候，计数器递减1，如果计数器为0了，那么就释放该心跳类。
基本的设计思想就是以上这些，代码用C++或者java会很简单，我是基于VC++开发的，用到了很多的MFC类型，很无奈，本人不喜欢微软的东西，但是由于工作需要实在不爽啊，这个设计有一个要点，就是共享的处理，我用到了很常用的懒惰管理法，就是用一个计数器，linux内核中这种方法很常见的，有空可以读一读，比如文件删除，页面释放等等，现在呈上代码：
以下为.h文件：
class HeartBeatClient;
class SERVER{ //保存服务器，目前就两个字段
public:
char strIP[200];
int iPort;
};
class LIST //保存vector，易于更换容器而不影响心跳类
{
public:
std::vector m_clientlist;
};
typedef struct{ //保存心跳反馈的结果
int m_iHeartBeat;
int m_iStatus;
}CON_RESULT,*PCON_RESULT;
class HeartBeatClient
{
public:
HeartBeatClient();
HeartBeatClient( char * strIP, int port );
~HeartBeatClient(void);
void SetIPandPort(char * strIP, int port);
int StartHeartBeatThread(void);
int StopHeartBeatThread(void);
void SetCheckConResult( CON_RESULT pResult );
void GetCheckConResult( CON_RESULT* pResult );
/*
* 是否已经有了关于这个端口和IP的心跳线程
* 返回值：如果没有，返回NULL；如果已经存在，那么就返回已经存在的那个
*/
HeartBeatClient* Exist( HeartBeatClient * pThis );
public:
<连接实体> m_CheckClient;
SERVER m_pServer;
int m_iRunning;
private:
CON_RESULT m_Result;
HANDLE m_hCheckClient;
int m_iThisOK;
int m_iShared; //共享一个心跳线程的线程数量
public:
static LIST m_slist;
};
以下为.cpp文件
#include "MirHeartBeatClient.h"
#include
LIST HeartBeatClient::m_slist;
DWORD WINAPI CheckClientFunc( LPVOID lpParam )
{
HeartBeatClient *pLocalCheckCon = (HeartBeatClient*)lpParam;
<连接实体>* localCheckClient = pLocalCheckCon->m_pCheckClient;
CON_RESULT result;
while(pLocalCheckCon->m_iRunning)
{
...设置默认result
pLocalCheckCon->SetCheckConResult(result);
...连接实体连接服务器
while(pLocalCheckCon->m_iRunning)
{
...发送实体发送心跳包
if (正确返回)
{
...设置正确反馈结果
pLocalCheckCon->SetCheckConResult(result);
Sleep(3000);
continue;
}
else
{
...设置错误反馈结果
pLocalCheckCon->SetCheckConResult(result);
...连接实体断开连接
Sleep(1000);
break;
}
}
}
return 1;
}
HeartBeatClient::HeartBeatClient( )
{
m_iThisOK = 0;
m_iRunning = 0;
m_hCheckClient = NULL;
m_Result.m_iHeartBeat = 0;
m_Result.m_iStatus = 0;
}
HeartBeatClient::HeartBeatClient( char * strIP, int port )
{
m_iThisOK = 0;
m_iRunning = 0;
m_hCheckClient = NULL;
...初始化连接实体
m_pServer.iPort = port;
strcpy( m_pServer.strIP, strIP );
m_Result.m_iHeartBeat = 0;
m_Result.m_iStatus = 0;
int nFound = -1;
if( m_slist.m_clientlist.size() > 0 )
for (int i=m_slist.m_clientlist.size()-1; i>=0; i--)
{
if( m_slist.m_clientlist[i]->m_pServer.iPort == port && !strcmp(m_slist.m_clientlist[i]->m_pServer.strIP,strIP) )
{
nFound = i;
m_slist.m_clientlist[i]->m_iShared++; //递增共享变量
}
}
if( nFound == -1 )
{
m_slist.m_clientlist.push_back(this);
m_iShared = 0;
m_iThisOK = 1;
m_iRunning = 1;
}
}
HeartBeatClient::~HeartBeatClient()
{
m_iRunning = 0;
...连接实体的断开处理
}
void HeartBeatClient::SetIP( char * strIP, int port )
{
m_pServer.iPort = port;
strcpy( m_pServer.strIP, strIP );
int nFound = -1;
if( m_slist.m_clientlist.size() > 0 )
for (int i=m_slist.m_clientlist.size()-1; i>=0; i--)
{
if( m_slist.m_clientlist[i]->m_pServer.iPort == port && !strcmp(m_slist.m_clientlist[i]->m_pServer.strIP,strIP) )
{
nFound = i;
m_slist.m_clientlist[i]->m_iShared++; //递增共享变量
}
}
if( nFound == -1 )
{
m_slist.m_clientlist.push_back(this);
m_iShared = 0;
m_iThisOK = 1;
m_iRunning = 1;
}
}
int HeartBeatClient::StartHeartBeatThread()
{
DWORD dwCheckThreadId;
m_hCheckClient = CreateThread( NULL, 0, CheckClientFunc, (LPVOID)this, 0, &dwCheckThreadId);
return 1;
}
void HeartBeatClient::GetCheckConResult(CON_RESULT * pConResult)
{
pConResult->m_iHeartBeat = m_Result.m_iHeartBeat;
pConResult->m_iStatus = m_Result.m_iStatus;
}
void HeartBeatClient::SetCheckConResult(CON_RESULT result)
{
m_Result.m_iHeartBeat = result.m_iHeartBeat;
m_Result.m_iStatus = result.m_iStatus;
}
HeartBeatClient* HeartBeatClient::Exist(HeartBeatClient* pThis)
{
int nFound = -1;
if( m_slist.m_clientlist.size() > 0 && m_iThisOK == 0 )
for (int i=m_slist.m_clientlist.size()-1; i>=0; i--)
{
if( m_slist.m_clientlist[i]->m_pServer.iPort == m_pServer.iPort && !strcmp(m_slist.m_clientlist[i]->m_pServer.strIP,m_pServer.strIP) )
{
return m_slist.m_clientlist[i]; //返回找到的
}
}
return NULL;
}
int HeartBeatClient::StopHeartBeatThread(void)
{
this->m_iShared --;
if( this->m_iShared == -1 )
{
if( m_hCheckClient != NULL )
{ //如果最后一个使用该对象的心跳类被停止，那么将自己从vector删除掉
std::vector ::iterator it;
it = find(m_slist.m_clientlist.begin(),m_slist.m_clientlist.end(),this);
if ( it!=m_slist.m_clientlist.end() )
m_slist.m_clientlist.erase(it);
m_iRunning = 0;
WaitForSingleObject( m_hCheckClient, INFINITE );
CloseHandle( m_hCheckClient );
m_hCheckClient = NULL;
}
return 1;
}
if( this->m_iShared < -1 )
this->m_iShared = 0;
return 0;
}
使用方式如下：
if ( m_pHeartBeatClient==NULL )
{
HeartBeatClient *pHeartBeat = NULL;
m_pHeartBeatClient = new HeartBeatClient( sWebIP, 8000 );
pHeartBeat = m_pHeartBeatClient->Exist( m_pHeartBeatClient );
if( !pHeartBeat )
{
m_pHeartBeatClient->StartHeartBeatThread();
}
else
{
m_pHeartBeatClient->StopHeartBeatThread(void)
delete m_pHeartBeatClient;
m_pHeartBeatClient = pHeartBeat;
}
}
想得到心跳结果的话，可以往心跳对象的GetCheckConResult中传入一个传出参数，调用完毕后结果就有了。这里用vector作为容器，其实是为了跨平台，在同样达到跨平台目的的前提下也完全可以用一种C++的特性来自己实现一个更好的容器，就是先实现一个高效的算法，并且实现容器的特有操作，比如插入，删除，查找等等，涉及到比较操作可以重载被比较对象的==操作符，这样就比较美观了，起初我就是这么实现的，但是后来别人说为了这个小玩意搞这么复杂太不值得了，于是就改成了比较传统的方式了。