socket心跳超时检测，快速处理新思路（适用于超大量TCP连接情况下）
假设一种情景：TCP服务器有1万个客户端连接，如果客户端5秒钟不发数据，则要断开。服务端如何检测客户端是否超时？这看起来是一个非常简单的问题，其实不然！
最简单的处理方法是：启动一个线程，每隔一段时间，检查每个连接是否超时。每次处理需要1万次检查。计算量太大！检查的时间间隔不能太小，否则大大增加计算量；如果间隔时间太大，超时误差会增大。
本文提出一种新颖的处理方法，就是针对这个看似简单而不易解决的问题！（以下用socket表示一个客户端连接）
1 内存布局图
假设socket3有新的数据到达，需要更新socket3所在的时间轴，处理逻辑如下：
2 处理过程分析：
基本的处理思路就是增加时间轴概念。将socket按最后更新时间排序。因为时间是连续的，不可能将时间分割太细。首先将时间离散，比如属于同一秒内的更新，被认为是属于同一个时间点。离散的时间间隔称为时间刻度，该刻度值可以根据具体情况调整。刻度值越小，超时计算越精确；但是计算量增大。如果时间刻度为10毫秒，则一秒的时间长度被划分为100份。所以需要对更新时间做规整，代码如下：
DateTime CreateNow() { DateTime now = DateTime.Now; int m = 0; if(now.Millisecond != 0) { if(_minimumScaleOfMillisecond == 1000) { now = now.AddSeconds(1); //尾数加1，确保超时值大于 给定的值 } else { //如果now.Millisecond为16毫秒，精确度为10毫秒。则转换后为20毫秒 m = now.Millisecond - now.Millisecond % _minimumScaleOfMillisecond + _minimumScaleOfMillisecond; if(m>=1000) { m -= 1000; now = now.AddSeconds(1); } } } 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有新的数据到达时，处理步骤：
- 查找socket的上一个群组。如果该群组对应的时刻和当前时刻相同（时间都已经离散，才有可能相同），无需更新时间轴。
- 从旧的群组删除，增加到新的群组。
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 > 0) { //时间轴从旧到新，查找对比 SameTimeKeyGroup<T> group = _listTimeScale[0]; if(timeLimit >= group.TimeStamp) { foreach (T key in group.KeyGroup) { result.Add(key); if (remove) { _socketToSameTimeKeyGroup.Remove(key); } } if(remove) { _listTimeScale.RemoveAt(0); } } else { break; } } return result; }
3 使用举例
//创建变量。最大超时时间为600秒，时间刻度为1秒 TimeSpanManage<Socket> _deviceActiveManage = TimeSpanManage<Socket>.Create(TimeSpan.FromSeconds(600), 1000); //当有数据到达时，调用更新函数 _deviceActiveManage.UpdateTime(socket); //需要在线程或定时器中，每隔一段时间调用，找出超时的socket //找出超时时间超过600秒的socket。 foreach (Socket socket in _deviceActiveManage.GetTimeoutValue(DateTime.Now.AddSeconds(-600))) { socket.Close(); }
4 完整代码
1 /// <summary> 2 /// 超时时间 时间间隔处理 3 /// </summary> 4 class TimeSpanManage<T> 5 { 6 TimeSpan _maxSpan; 7 int _minimumScaleOfMillisecond; 8 int _scaleCount; 9 10 List<SameTimeKeyGroup<T>> _listTimeScale = new List<SameTimeKeyGroup<T>>(); 11 private TimeSpanManage() 12 { 13 } 14 15 /// <summary> 16 /// 17 /// </summary> 18 /// <param name="maxSpan">最大时间时间</param> 19 /// <param name="minimumScaleOfMillisecond">最小刻度（毫秒）</param> 20 /// <returns></returns> 21 public static TimeSpanManage<T> Create(TimeSpan maxSpan, int minimumScaleOfMillisecond) 22 { 23 if (minimumScaleOfMillisecond <= 0) 24 throw new Exception("minimumScaleOfMillisecond 小于0"); 25 if (minimumScaleOfMillisecond > 1000) 26 throw new Exception("minimumScaleOfMillisecond 不能大于1000"); 27 28 if (maxSpan.TotalMilliseconds <= 0) 29 throw new Exception("maxSpan.TotalMilliseconds 小于0"); 30 31 TimeSpanManage<T> result = new TimeSpanManage<T>(); 32 result._maxSpan = maxSpan; 33 result._minimumScaleOfMillisecond = minimumScaleOfMillisecond; 34 35 result._scaleCount = (int)(maxSpan.TotalMilliseconds / minimumScaleOfMillisecond); 36 result._scaleCount++; 37 return result; 38 } 39 40 Dictionary<T, SameTimeKeyGroup<T>> _socketToSameTimeKeyGroup = new Dictionary<T, SameTimeKeyGroup<T>>(); 41 public void UpdateTime(T key) 42 { 43 DateTime now = CreateNow(); 44 //是否已存在,从上一个时间群组删除 45 if (_socketToSameTimeKeyGroup.ContainsKey(key)) 46 { 47 SameTimeKeyGroup<T> group = _socketToSameTimeKeyGroup[key]; 48 if (group.ContainKey(key)) 49 { 50 if (group.TimeStamp == now) //同一时间更新，无需移动 51 { 52 return; 53 } 54 else 55 { 56 group.RemoveKey(key); 57 _socketToSameTimeKeyGroup.Remove(key); 58 } 59 } 60 } 61 62 //从超时组 删除 63 _timeoutSocketGroup.Remove(key); 64 65 //加入到新组 66 SameTimeKeyGroup<T> groupFromScaleList = GetOrCreateSocketGroup(now, out bool newCreate); 67 groupFromScaleList.AddKey(key); 68 69 _socketToSameTimeKeyGroup.Add(key, groupFromScaleList); 70 71 if (newCreate) 72 { 73 AdjustTimeout(); 74 } 75 } 76 77 public bool RemoveSocket(T key) 78 { 79 bool result = false; 80 if (_socketToSameTimeKeyGroup.ContainsKey(key)) 81 { 82 SameTimeKeyGroup<T> group = _socketToSameTimeKeyGroup[key]; 83 result = group.RemoveKey(key); 84 85 _socketToSameTimeKeyGroup.Remove(key); 86 } 87 88 //从超时组 删除 89 bool result2 = _timeoutSocketGroup.Remove(key); 90 return result || result2; 91 } 92 93 /// <summary> 94 ///timeLimit 值为超时时刻限制 95 ///比如DateTime.Now.AddMilliseconds(-1000);表示 返回一秒钟以前的数据 96 /// </summary> 97 /// <param name="timeLimit">该时间以前的socket会被返回</param> 98 /// <returns></returns> 99 public List<T> GetTimeoutValue(DateTime timeLimit, bool remove = true) 100 { 101 if((DateTime.Now - timeLimit) > _maxSpan ) 102 { 103 Debug.Write("GetTimeoutSocket timeLimit 参数有误！"); 104 } 105 106 //从超时组 读取 107 List<T> result = new List<T>(); 108 foreach(T key in _timeoutSocketGroup) 109 { 110 _timeoutSocketGroup.Add(key); 111 } 112 113 if(remove) 114 { 115 _timeoutSocketGroup.Clear(); 116 } 117 118 while (_listTimeScale.Count > 0) 119 { 120 //时间轴从旧到新，查找对比 121 SameTimeKeyGroup<T> group = _listTimeScale[0]; 122 if(timeLimit >= group.TimeStamp) 123 { 124 foreach (T key in group.KeyGroup) 125 { 126 result.Add(key); 127 if (remove) 128 { 129 _socketToSameTimeKeyGroup.Remove(key); 130 } 131 } 132 133 if(remove) 134 { 135 _listTimeScale.RemoveAt(0); 136 } 137 } 138 else 139 { 140 break; 141 } 142 } 143 144 return result; 145 } 146 147 HashSet<T> _timeoutSocketGroup = new HashSet<T>(); 148 private void AdjustTimeout() 149 { 150 while (_listTimeScale.Count > _scaleCount) 151 { 152 SameTimeKeyGroup<T> group = _listTimeScale[0]; 153 foreach (T key in group.KeyGroup) 154 { 155 _timeoutSocketGroup.Add(key); 156 } 157 158 _listTimeScale.RemoveAt(0); 159 } 160 } 161 162 private SameTimeKeyGroup<T> GetOrCreateSocketGroup(DateTime now, out bool newCreate) 163 { 164 if (_listTimeScale.Count == 0) 165 { 166 newCreate = true; 167 SameTimeKeyGroup<T> result = new SameTimeKeyGroup<T>(now); 168 _listTimeScale.Add(result); 169 return result; 170 } 171 else 172 { 173 SameTimeKeyGroup<T> lastGroup = _listTimeScale[_listTimeScale.Count - 1]; 174 if (lastGroup.TimeStamp == now) 175 { 176 newCreate = false; 177 return lastGroup; 178 } 179 180 newCreate = true; 181 SameTimeKeyGroup<T> result = new SameTimeKeyGroup<T>(now); 182 _listTimeScale.Add(result); 183 return result; 184 } 185 } 186 187 DateTime CreateNow() 188 { 189 DateTime now = DateTime.Now; 190 int m = 0; 191 if(now.Millisecond != 0) 192 { 193 if(_minimumScaleOfMillisecond == 1000) 194 { 195 now = now.AddSeconds(1); //尾数加1，确保超时值大于 给定的值 196 } 197 else 198 { 199 //如果now.Millisecond为16毫秒，精确度为10毫秒。则转换后为20毫秒 200 m = now.Millisecond - now.Millisecond % _minimumScaleOfMillisecond + _minimumScaleOfMillisecond; 201 if(m>=1000) 202 { 203 m -= 1000; 204 now = now.AddSeconds(1); 205 } 206 } 207 } 208 return new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second,m); 209 } 210 } 211 212 class SameTimeKeyGroup<T> 213 { 214 DateTime _timeStamp; 215 public DateTime TimeStamp => _timeStamp; 216 public SameTimeKeyGroup(DateTime time) 217 { 218 _timeStamp = time; 219 } 220 public HashSet<T> KeyGroup { get; set; } = new HashSet<T>(); 221 222 public bool ContainKey(T key) 223 { 224 return KeyGroup.Contains(key); 225 } 226 227 internal void AddKey(T key) 228 { 229 KeyGroup.Add(key); 230 } 231 internal bool RemoveKey(T key) 232 { 233 return KeyGroup.Remove(key); 234 } 235 }
View Code
版权声明：本文为yuanchenhui原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。