private void ProReceiveDataThreadMethod(ThreadExPara para)
{
try
{
Stopwatch watch = new Stopwatch();
ReceiveDatagramInfo receiveDatagramInfo;
CancellationToken token = this._parseDataThreadsCts.Token;
while (!token.IsCancellationRequested)
{
try
{
try
{
receiveDatagramInfo = this._waitParseDatas.Take(token);
}
catch (ArgumentNullException)
{
Loger.Error(".net平台库ArgumentNullException异常,忽略");
continue;
}
catch (ObjectDisposedException)
{
continue;
}
catch (OperationCanceledException)
{
continue;
}
catch (InvalidOperationException)
{
continue;
}
watch.Restart();
this.ProReceiveData(receiveDatagramInfo);
watch.Stop();
if (watch.ElapsedMilliseconds > this._config.ProReceiveDataAddThreadTimeout)
{
this.AddParseDispoatchThread();
}
}
catch (Exception exi)
{
Loger.Error(exi, $"{Thread.CurrentThread.Name}发生异常");
}
}
}
catch (OperationCanceledException)
{ }
catch (ObjectDisposedException)
{ }
catch (Exception ex)
{
Loger.Error(ex);
}
}
private void ParseData(ThreadExPara para)
{
const int millisecondsTimeout = 500;
byte[] parsePackgeBuffer = new byte[TransferConstant.MTU_MAX * 3];
using (var ms = new MemoryStream(parsePackgeBuffer))
{
var br = new BinaryReader(ms);
int writePostion = 0;
int parsePostion = 0;
byte[] buffer;
while (!para.Token.IsCancellationRequested)
{
try
{
try
{
if (!this._parseDatas.TryTake(out buffer, millisecondsTimeout, para.Token))
{
continue;
}
}
catch (ArgumentNullException)
{
continue;
}
catch (OperationCanceledException)
{
continue;
}
catch (ObjectDisposedException)
{
continue;
}
catch (InvalidOperationException)
{
continue;
}
//合并数据
this.MergeData(parsePackgeBuffer, ref writePostion, ref parsePostion, buffer);
//数据拆包
this.SplitPackge(writePostion, ref parsePostion, br, parsePackgeBuffer);
}
catch (Exception ex)
{
Loger.Error(ex, "tlv拆包异常");
}
}
}
}
private void ReqDataThreadMethod(ThreadExPara para)
{
const int reqDataThreadsEventHandleTimeout = 2000;
int currentThreadId = Thread.CurrentThread.ManagedThreadId;
var reqDataThreadsEventHandle = (AutoResetEvent)para.Para;
TransferReqDataSchduleInfoManager reqDataSchduleInfoManager = null;
TransferReqDataSchduleInfo currentReqDataSchduleInfo;
bool hasSendTransferCompletedMessageLock;
while (!para.Token.IsCancellationRequested)
{
try
{
//var watch = System.Diagnostics.Stopwatch.StartNew();
hasSendTransferCompletedMessageLock = this.GetReqDataSchduleInfo(currentThreadId, out reqDataSchduleInfoManager, out currentReqDataSchduleInfo);
//watch.Stop();
//if (reqDataSchduleInfoManager != null)
//{
// Loger.Warn($"RID[{reqDataSchduleInfoManager.NotifyMessage.Header.Rid}]GetReqDataSchduleInfo耗时{watch.Elapsed.Milliseconds}毫秒");
//}
if (hasSendTransferCompletedMessageLock)
{
this.SendTransferCompletedMessage(reqDataSchduleInfoManager.NotifyMessage);
}
else
{
if (reqDataSchduleInfoManager == null || currentReqDataSchduleInfo == null)
{
try
{
reqDataThreadsEventHandle.WaitOne(reqDataThreadsEventHandleTimeout);
}
catch (ObjectDisposedException)
{
break;
}
}
else
{
this.PrimitiveReqData(reqDataSchduleInfoManager, currentReqDataSchduleInfo);
}
}
}
catch (Exception ex)
{
Loger.Error(ex, "请求数据异常");
}
}
}
private void ExpirationChaeckThreadMethod(ThreadExPara para)
{
try
{
CacheItem[] cacheItemArr;
while (!para.Token.IsCancellationRequested)
{
try
{
para.Token.WaitHandle.WaitOne(this._checkIntervalMillisecondsTimeout, true);
}
catch (ObjectDisposedException)
{
break;
}
catch (AbandonedMutexException)
{
break;
}
catch (InvalidOperationException)
{
break;
}
try
{
cacheItemArr = this._cacheDic.Values.ToArray();
foreach (var cacheItem in cacheItemArr)
{
if (cacheItem.Expiration())
{
this.ExpirationRemove(cacheItem.Key);
}
}
this.StopExpirationChaeckThread();
}
catch (Exception exi)
{
Loger.Error(exi);
}
}
}
catch (Exception ex)
{
Loger.Error(ex);
}
}
private void Create(ThreadExPara para)
{
int count = 0;
while (!para.Token.IsCancellationRequested && count < 100000)
{
count++;
count++;
count++;
count++;
this._apQueue.Enqueue(_rnd.Next(1, 100));
}
//for (int i = 0; i < 10; i++)
//{
// this._apQueue.Enqueue(_rnd.Next(1, 100));
//}
}
private void CopyRevDataThreadMethod(ThreadExPara para)
{
RevDataInfo revDataPosition;
while (!para.Token.IsCancellationRequested)
{
try
{
revDataPosition = this._revDataPositions.Take(para.Token);
this._revBufferParseOffset = revDataPosition.Offset;
byte[] buffer = new byte[revDataPosition.Length];
Array.Copy(this._revBuffer, revDataPosition.Offset, buffer, 0, revDataPosition.Length);
this._rev(new ReceiveDatagramInfo(buffer, revDataPosition.RemoteEP));
}
catch (ArgumentNullException)
{
//.net bug
continue;
}
catch (OperationCanceledException)
{ }
catch (ObjectDisposedException)
{
break;
}
catch (InvalidOperationException)
{
break;
}
catch (Exception ex)
{
Loger.Error(ex, "ProRevRevDataPosition异常");
}
}
}
private void ThreadMethod(ThreadExPara para)
{
try
{
while (!para.Token.IsCancellationRequested)
{
try
{
if (para.WaitOne(10000))
{
continue;
}
}
catch (ObjectDisposedException)
{
continue;
}
}
}
catch (Exception ex)
{
Loger.Error(ex);
}
}
private void PlayLineThreadMethod(ThreadExPara threadPara)
{
double durationSeconds = (double)threadPara.Para * 1000;
double offsetTimeMilliseconds = 0d;
int interval = 100;
while (!threadPara.Token.IsCancellationRequested && offsetTimeMilliseconds < durationSeconds)
{
threadPara.WaitOne(interval);
if (this._offsetMilliseconds.HasValue)
{
offsetTimeMilliseconds = this._offsetMilliseconds.Value;
this._offsetMilliseconds = null;
}
IAsyncResult asyncResult = this.BeginInvoke(new Action <double>((d) =>
{
waveControl.UpdatePostionLine(d);
}), new object[] { offsetTimeMilliseconds });
asyncResult.AsyncWaitHandle.WaitOne();
offsetTimeMilliseconds += interval;
}
}
private void RevTimeoutCheckThreadMethod(ThreadExPara para)
{
const int defaultTimeoutCheckInveral = 100;
int timeoutCheckInveral = defaultTimeoutCheckInveral;
ReceiveDataItem[] revItems;
SendDataNotifyMessage notifyMessage;
while (!para.Token.IsCancellationRequested)
{
try
{
revItems = this._revItemDic.Values.ToArray();
if (revItems.Length == 0)
{
try
{
this._revNewDataNoyifyEventHandle.WaitOne(30000);
}
catch (ObjectDisposedException)
{ }
continue;
}
timeoutCheckInveral = defaultTimeoutCheckInveral;
foreach (var revItem in revItems)
{
try
{
notifyMessage = revItem.NotifyMessage;
if (revItem.IsTimeout())
{
//Loger.Warn($"RID:[{notifyMessage.Header.Rid}]传输超时,最后一次收到数据时间[{TimeEx.TimestampToDateTime(revItem.LastAccessTimestamp).AddHours(8).ToString("HH:mm:ss.fffffff")}]从传输列表中移除该项");
MemoryCacheEx.Set(CacheKeyGenerator.GenerateRevTimeoutKey(notifyMessage.Header.Rid), notifyMessage.Header.Rid, revItem.MillisecondsTimeout);
this.RemoveTransferItem(notifyMessage.Header.Rid, false);
}
else
{
if (timeoutCheckInveral > notifyMessage.Timeout)
{
timeoutCheckInveral = notifyMessage.Timeout;
}
}
}
catch (Exception exi)
{
Loger.Error(exi);
}
}
notifyMessage = null;
}
catch (ObjectDisposedException)
{ }
catch (Exception ex)
{
Loger.Error(ex, "RevTimeoutCheckThreadMethod异常");
}
try
{
this._revTimeoutCheckEventHandle.WaitOne(timeoutCheckInveral);
}
catch (ObjectDisposedException)
{ }
}
}
private void ReceiveDtaThreadMethod(ThreadExPara para)
{
int bufLen = TransferConstant.MTU_MAX + 128;//原本+28(IP头20+udp头8)即可,为了靠谱点,大一点无所谓
byte[] buffer = new byte[bufLen];
int revBufferOffset = 0;
int revLen;
EndPoint remoteEP = new IPEndPoint(1, 1);
IPEndPoint tmpEndPoint;
while (this._status)
{
try
{
revLen = this._socket.ReceiveFrom(this._revBuffer, revBufferOffset, bufLen, SocketFlags.None, ref remoteEP);
if (revLen <= 0)
{
continue;
}
if (revBufferOffset >= _revBufferParseOffset)
{
if ((_REV_BUFFER_SIZE - this._revBufferParseOffset) < bufLen)
{
this.AddCopyRevDataThread(true);
}
}
else
{
if ((this._revBufferParseOffset - revBufferOffset) < bufLen)
{
this.AddCopyRevDataThread(true);
}
}
//if ((_REV_BUFFER_SIZE - this._revBufferParseOffset) < bufLen)
//{
// Loger.Warn("接收数据不及时,可能有数据被覆盖,多开一个线程用于拷贝接收到的数据");
// this.AddCopyRevDataThread(true);
//}
tmpEndPoint = (IPEndPoint)remoteEP;
this._revDataPositions.Add(new RevDataInfo(revBufferOffset, revLen, new IPEndPoint(new IPAddress(tmpEndPoint.Address.GetAddressBytes()), tmpEndPoint.Port)));
revBufferOffset += revLen;
if (_REV_BUFFER_SIZE - revBufferOffset < bufLen)
{
revBufferOffset = 0;
}
}
catch (ThreadAbortException)
{
break;
}
catch (ObjectDisposedException)
{
break;
}
catch (SocketException se)
{
//if (se.ErrorCode == 10054)
//{
// //windows底层的BUG,UDP本无连接,也不管是否到达,但是windows却诡异的报了这个BUG
// //网上有尝试其它方法,在初始化socket时设置socket内部控制行为,不晓得靠谱否,如果不靠谱则重新初始化
// this.InitSocket();
//}
//else
//{
// Loger.Error(se, "udp接收数据发生异常");
//}
Loger.Error(se, "udp接收数据发生异常");
}
catch (Exception ex)
{
Loger.Error(ex, "udp接收数据发生异常");
}
}
}
