假设一种情景:TCP服务器有1万个客户端连接,如果客户端5秒钟不发数据,则要断开。服务端如何检测客户端是否超时?这看起来是一个非常简单的问题,其实不然!

最简单的处理方法是:启动一个线程,每隔一段时间,检查每个连接是否超时。每次处理需要1万次检查。计算量太大!检查的时间间隔不能太小,否则大大增加计算量;如果间隔时间太大,超时误差会增大。

本文提出一种新颖的处理方法,就是针对这个看似简单而不易解决的问题!(以下用socket表示一个客户端连接)

 1 内存布局图

  

假设socket3有新的数据到达,需要更新socket3所在的时间轴,处理逻辑如下:

2 处理过程分析:

基本的处理思路就是增加时间轴概念。将socket按最后更新时间排序。因为时间是连续的,不可能将时间分割太细。首先将时间离散,比如属于同一秒内的更新,被认为是属于同一个时间点。离散的时间间隔称为时间刻度,该刻度值可以根据具体情况调整。刻度值越小,超时计算越精确;但是计算量增大。如果时间刻度为10毫秒,则一秒的时间长度被划分为100份。所以需要对更新时间做规整,代码如下:

     DateTime CreateNow()
{
DateTime now = DateTime.Now;
int m = ;
if(now.Millisecond != )
{
if(_minimumScaleOfMillisecond == )
{
now = now.AddSeconds(); //尾数加1,确保超时值大于 给定的值
}
else
{
//如果now.Millisecond为16毫秒,精确度为10毫秒。则转换后为20毫秒
m = now.Millisecond - now.Millisecond % _minimumScaleOfMillisecond + _minimumScaleOfMillisecond;
if(m>=)
{
m -= ;
now = now.AddSeconds();
}
}
}
return new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second,m);
}

属于同一个时间刻度的socket,被放入在一个哈希表中(见图中Group)。存放socket的类如下:

 class SameTimeKeyGroup<T>
{
DateTime _timeStamp;
public DateTime TimeStamp => _timeStamp;
public SameTimeKeyGroup(DateTime time)
{
_timeStamp = time;
}
public HashSet<T> KeyGroup { get; set; } = new HashSet<T>(); public bool ContainKey(T key)
{
return KeyGroup.Contains(key);
} internal void AddKey(T key)
{
KeyGroup.Add(key);
}
internal bool RemoveKey(T key)
{
return KeyGroup.Remove(key);
}
}

定义一个List表示时间轴:

 List<SameTimeKeyGroup<T>> _listTimeScale = new List<SameTimeKeyGroup<T>>();

在_listTimeScale 前端的时间较旧,所以链表前端就是有可能超时的socket。

当有socket需要更新时,需要快速知道socket所在的group。这样才能将socket从旧的group移走,再添加到新的group中。需要新增一个链表:

 Dictionary<T, SameTimeKeyGroup<T>> _socketToSameTimeKeyGroup = new Dictionary<T, SameTimeKeyGroup<T>>();

 2.1 当socket有新的数据到达时,处理步骤:

  1. 查找socket的上一个群组。如果该群组对应的时刻和当前时刻相同(时间都已经离散,才有可能相同),无需更新时间轴。
  2. 从旧的群组删除,增加到新的群组。
    public void UpdateTime(T key)
{
DateTime now = CreateNow();
//是否已存在,从上一个时间群组删除
if (_socketToSameTimeKeyGroup.ContainsKey(key))
{
SameTimeKeyGroup<T> group = _socketToSameTimeKeyGroup[key];
if (group.ContainKey(key))
{
if (group.TimeStamp == now) //同一时间更新,无需移动
{
return;
}
else
{
group.RemoveKey(key);
_socketToSameTimeKeyGroup.Remove(key);
}
}
} //从超时组 删除
_timeoutSocketGroup.Remove(key); //加入到新组
SameTimeKeyGroup<T> groupFromScaleList = GetOrCreateSocketGroup(now, out bool newCreate);
groupFromScaleList.AddKey(key); _socketToSameTimeKeyGroup.Add(key, groupFromScaleList); if (newCreate)
{
AdjustTimeout();
}
}

 2.2 获取超时的socket

 时间轴从旧到新,对比群组的时间与超时时刻。就是链表_listTimeScale,从0开始查找。

 /// <summary>
///timeLimit 值为超时时刻限制
///比如DateTime.Now.AddMilliseconds(-1000);表示 返回一秒钟以前的数据
/// </summary>
/// <param name="timeLimit">该时间以前的socket会被返回</param>
/// <returns></returns>
public List<T> GetTimeoutValue(DateTime timeLimit, bool remove = true)
{
if((DateTime.Now - timeLimit) > _maxSpan )
{
Debug.Write("GetTimeoutSocket timeLimit 参数有误!");
} //从超时组 读取
List<T> result = new List<T>();
foreach(T key in _timeoutSocketGroup)
{
_timeoutSocketGroup.Add(key);
} if(remove)
{
_timeoutSocketGroup.Clear();
} while (_listTimeScale.Count > )
{
//时间轴从旧到新,查找对比
SameTimeKeyGroup<T> group = _listTimeScale[];
if(timeLimit >= group.TimeStamp)
{
foreach (T key in group.KeyGroup)
{
result.Add(key);
if (remove)
{
_socketToSameTimeKeyGroup.Remove(key);
}
} if(remove)
{
_listTimeScale.RemoveAt();
}
}
else
{
break;
}
} return result;
}

3 使用举例

//创建变量。最大超时时间为600秒,时间刻度为1秒
TimeSpanManage<Socket> _deviceActiveManage = TimeSpanManage<Socket>.Create(TimeSpan.FromSeconds(), ); //当有数据到达时,调用更新函数
_deviceActiveManage.UpdateTime(socket); //需要在线程或定时器中,每隔一段时间调用,找出超时的socket
//找出超时时间超过600秒的socket。
foreach (Socket socket in _deviceActiveManage.GetTimeoutValue(DateTime.Now.AddSeconds(-)))
{
socket.Close();
}

4 完整代码

   /// <summary>
/// 超时时间 时间间隔处理
/// </summary>
class TimeSpanManage<T>
{
TimeSpan _maxSpan;
int _minimumScaleOfMillisecond;
int _scaleCount; List<SameTimeKeyGroup<T>> _listTimeScale = new List<SameTimeKeyGroup<T>>();
private TimeSpanManage()
{
} /// <summary>
///
/// </summary>
/// <param name="maxSpan">最大时间时间</param>
/// <param name="minimumScaleOfMillisecond">最小刻度(毫秒)</param>
/// <returns></returns>
public static TimeSpanManage<T> Create(TimeSpan maxSpan, int minimumScaleOfMillisecond)
{
if (minimumScaleOfMillisecond <= )
throw new Exception("minimumScaleOfMillisecond 小于0");
if (minimumScaleOfMillisecond > )
throw new Exception("minimumScaleOfMillisecond 不能大于1000"); if (maxSpan.TotalMilliseconds <= )
throw new Exception("maxSpan.TotalMilliseconds 小于0"); TimeSpanManage<T> result = new TimeSpanManage<T>();
result._maxSpan = maxSpan;
result._minimumScaleOfMillisecond = minimumScaleOfMillisecond; result._scaleCount = (int)(maxSpan.TotalMilliseconds / minimumScaleOfMillisecond);
result._scaleCount++;
return result;
} Dictionary<T, SameTimeKeyGroup<T>> _socketToSameTimeKeyGroup = new Dictionary<T, SameTimeKeyGroup<T>>();
public void UpdateTime(T key)
{
DateTime now = CreateNow();
//是否已存在,从上一个时间群组删除
if (_socketToSameTimeKeyGroup.ContainsKey(key))
{
SameTimeKeyGroup<T> group = _socketToSameTimeKeyGroup[key];
if (group.ContainKey(key))
{
if (group.TimeStamp == now) //同一时间更新,无需移动
{
return;
}
else
{
group.RemoveKey(key);
_socketToSameTimeKeyGroup.Remove(key);
}
}
} //从超时组 删除
_timeoutSocketGroup.Remove(key); //加入到新组
SameTimeKeyGroup<T> groupFromScaleList = GetOrCreateSocketGroup(now, out bool newCreate);
groupFromScaleList.AddKey(key); _socketToSameTimeKeyGroup.Add(key, groupFromScaleList); if (newCreate)
{
AdjustTimeout();
}
} public bool RemoveSocket(T key)
{
bool result = false;
if (_socketToSameTimeKeyGroup.ContainsKey(key))
{
SameTimeKeyGroup<T> group = _socketToSameTimeKeyGroup[key];
result = group.RemoveKey(key); _socketToSameTimeKeyGroup.Remove(key);
} //从超时组 删除
bool result2 = _timeoutSocketGroup.Remove(key);
return result || result2;
} /// <summary>
///timeLimit 值为超时时刻限制
///比如DateTime.Now.AddMilliseconds(-1000);表示 返回一秒钟以前的数据
/// </summary>
/// <param name="timeLimit">该时间以前的socket会被返回</param>
/// <returns></returns>
public List<T> GetTimeoutValue(DateTime timeLimit, bool remove = true)
{
if((DateTime.Now - timeLimit) > _maxSpan )
{
Debug.Write("GetTimeoutSocket timeLimit 参数有误!");
} //从超时组 读取
List<T> result = new List<T>();
foreach(T key in _timeoutSocketGroup)
{
_timeoutSocketGroup.Add(key);
} if(remove)
{
_timeoutSocketGroup.Clear();
} while (_listTimeScale.Count > )
{
//时间轴从旧到新,查找对比
SameTimeKeyGroup<T> group = _listTimeScale[];
if(timeLimit >= group.TimeStamp)
{
foreach (T key in group.KeyGroup)
{
result.Add(key);
if (remove)
{
_socketToSameTimeKeyGroup.Remove(key);
}
} if(remove)
{
_listTimeScale.RemoveAt();
}
}
else
{
break;
}
} return result;
} HashSet<T> _timeoutSocketGroup = new HashSet<T>();
private void AdjustTimeout()
{
while (_listTimeScale.Count > _scaleCount)
{
SameTimeKeyGroup<T> group = _listTimeScale[];
foreach (T key in group.KeyGroup)
{
_timeoutSocketGroup.Add(key);
} _listTimeScale.RemoveAt();
}
} private SameTimeKeyGroup<T> GetOrCreateSocketGroup(DateTime now, out bool newCreate)
{
if (_listTimeScale.Count == )
{
newCreate = true;
SameTimeKeyGroup<T> result = new SameTimeKeyGroup<T>(now);
_listTimeScale.Add(result);
return result;
}
else
{
SameTimeKeyGroup<T> lastGroup = _listTimeScale[_listTimeScale.Count - ];
if (lastGroup.TimeStamp == now)
{
newCreate = false;
return lastGroup;
} newCreate = true;
SameTimeKeyGroup<T> result = new SameTimeKeyGroup<T>(now);
_listTimeScale.Add(result);
return result;
}
} DateTime CreateNow()
{
DateTime now = DateTime.Now;
int m = ;
if(now.Millisecond != )
{
if(_minimumScaleOfMillisecond == )
{
now = now.AddSeconds(); //尾数加1,确保超时值大于 给定的值
}
else
{
//如果now.Millisecond为16毫秒,精确度为10毫秒。则转换后为20毫秒
m = now.Millisecond - now.Millisecond % _minimumScaleOfMillisecond + _minimumScaleOfMillisecond;
if(m>=)
{
m -= ;
now = now.AddSeconds();
}
}
}
return new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second,m);
}
} class SameTimeKeyGroup<T>
{
DateTime _timeStamp;
public DateTime TimeStamp => _timeStamp;
public SameTimeKeyGroup(DateTime time)
{
_timeStamp = time;
}
public HashSet<T> KeyGroup { get; set; } = new HashSet<T>(); public bool ContainKey(T key)
{
return KeyGroup.Contains(key);
} internal void AddKey(T key)
{
KeyGroup.Add(key);
}
internal bool RemoveKey(T key)
{
return KeyGroup.Remove(key);
}
}

socket心跳超时检测,快速处理新思路(适用于超大量TCP连接情况下)的更多相关文章

  1. 正常断开连接情况下,判断非阻塞模式socket连接是否断开

    摘自:http://blog.chinaunix.net/uid-15014334-id-3429627.html 在UNIX/LINUX下, 1,对于主动关闭的SOCKET, recv返回-1,而且 ...

  2. 初步探究java中程序退出、GC垃圾回收时,socket tcp连接的行为

    初步探究java中程序退出.GC垃圾回收时,socket tcp连接的行为 今天在项目开发中需要用到socket tcp连接相关(作为tcp客户端),在思考中发觉需要理清socket主动.被动关闭时发 ...

  3. socket心跳检测

    一.什么是心跳检测 判断对方(设备,进程或其它网元)是否正常动行,一般采用定时发送简单的通讯包,如果在指定时间段内未收到对方响应,则判断对方已经当掉.用于检测TCP的异常断开. 基本原因是服务器端不能 ...

  4. [转] Socket心跳包异常检测的C语言实现,服务器与客户端代码案例

    转载自:zxh2075的专栏 在Socket心跳机制中,心跳包可以由服务器发送给客户端,也可以由客户端发送给服务器,不过比较起来,前者开销可能较大.本文实现的是由客户端给服务器发送心跳包,服务器不必返 ...

  5. Socket心跳包异常检测的C语言实现,服务器与客户端代码案例

    在Socket心跳机制中,心跳包可以由服务器发送给客户端,也可以由客户端发送给服务器,不过比较起来,前者开销可能较大.本文实现的是由客户端给服务器发送心跳包,服务器不必返回应答包,而是通过判断客户在线 ...

  6. web socket 心跳包的实现方案

    web socket 心跳包的实现方案05/30/2010 现在网络环境错综复杂,socket心跳包是获得健康强壮的连接的有效解决方案,今天,我们就在web socket中实现心跳包方案,是的,尽管我 ...

  7. socket 心跳包机制

    心跳包的发送,通常有两种技术 方法1:应用层自己实现的心跳包  由应用程序自己发送心跳包来检测连接是否正常,大致的方法是:服务器在一个 Timer事件中定时 向客户端发送一个短小精悍的数据包,然后启动 ...

  8. Socket心跳包机制【转】

    转自:https://blog.csdn.net/xuyuefei1988/article/details/8279812 心跳包的发送,通常有两种技术 方法1:应用层自己实现的心跳包 由应用程序自己 ...

  9. Socket心跳包机制总结【转】

    转自:https://blog.csdn.net/qq_23167527/article/details/54290726 跳包之所以叫心跳包是因为:它像心跳一样每隔固定时间发一次,以此来告诉服务器, ...

随机推荐

  1. MySql 存储过程、触发器和权限问题

    存储过程 1.1 什么是存储过程 存储过程,带有逻辑的sql语句 之前的sql没有条件判断,没有循环 存储过程带上流程控制语句(if  while) 1.2 存储过程特点 1)执行效率非常快!存储过程 ...

  2. 让IE支持placeholder属性~

    原文:https://www.oschina.net/code/snippet_206691_26471#44160 让支持的直接路过,不支持的,完美显示~~ /*  * jQuery placeho ...

  3. php生成UUID

    UUID含义是 通用唯一识别码 (Universally Unique Identifier),这 是一个软件建构的标准,也是被开源软件基金会 (Open Software Foundation, O ...

  4. Jsoup解析HTML、加载文档等实例

    一.引入jsoup的jar包:http://jsoup.org/download 补充:http://jsoup.org/apidocs/   Jsoup API    可以了解更详细的内容 二.Js ...

  5. java如何引入接口中定义的常量

    接口 (A.java) : package config; public interface A { String PROJECT_ROOT_DIR = System.getProperty(&quo ...

  6. VC 编程ANSI环境下读写Unicode文件

    没有注意到文件编码的不同会产生这么多的问题,在动手以前查询了很多资料,在本博客中收藏了不少先辈的成果,在这里一并表示致敬!       关于ANSI和Unicode编码的原理在这里也不说了,主要讲下如 ...

  7. PPT要你好看---读书笔记

    PPT要你好看.主要是设计的思维. 下图,对于现阶段的我来说,收获最大的是毕业答辩PPT的制作. 以及整体的PPT制作思路.

  8. WinCC OA基本概念

    WinCC OA 是一个模块化软件架构的系统.所需的功能由不同任务创建的特定单元处理.在WinCC OA中,这些单元称为管理器 - 管理器是软件自身的一些独立的处理过程. 图:WinCC OA系统由功 ...

  9. 【项目 &#183; WonderLand】 系 统 设 计

    团 队 作 业 ---- 系 统 设 计 Part 0 · 简 要 目 录 Part 1 · 完 善 需 求 规 格 说 明 书 Part 2 · 团 队 编 码 规 范 Part 3 · 数 据 库 ...

  10. 原来Github上的README.md文件这么有意思——Markdown语言详解(sublime text2 版本)

    一直想学习 Markdown 语言,想起以前读的一篇 赵凯强 的 博客 <原来Github上的README.md文件这么有意思——Markdown语言详解>,该篇博主 使用的是Mac系统, ...