异步Socket接收数据后缓存处理问题

最新推荐文章于 2022-10-10 09:07:51 发布
最新推荐文章于 2022-10-10 09:07:51 发布
阅读量4.1k 收藏 1
点赞数
分类专栏： C#
异步接收数据都正常，是个定长TLV包，但是接收到后都是直接写入bufflist后再getdata出来处理，发现有时会有掉包情况，以为是线程安全问题，后来加入了lock段将bufflist内代码锁住，依然会有掉包现象，导致组包失败，请教了一些人，回答仍然是线程安全问题，请问是否有更好的处理办法，如有请贴出代码，因为理论我都明白，也不是解包问题（这个解包方式只是随便写的简单方式）现需要能实际解决缓存数据包问题的方法
C# code 
    
    

     
     
                        user.BuffList.InsertByteArray(data); 
     
     //
     
     插入数据包缓冲池
     
     
                        
     
     do
                        {
                            
     
     try
                            {
                                
     
     byte[] buff = user.BuffList.GetData(); 
     
     //
     
     取出存在的数据包
     
     
                                
     
     if (buff == 
     
     null)
                                    
     
     break;
                                DataHandler(buff, user); 
     
     //
     
     将每个数据包指令进行处理
     
     
                            }
                            
     
     catch
                            {
                                
     
     //
     
     取包异常
     
     
                            }
                        } 
     
     while (
     
     true);


C# code 
    
    

    
     
     public 
     
     class BuffList
    {
        
     
     public 
     
     object locklist = 
     
     new 
     
     object();

        
     
     public List<
     
     byte> ByteList { 
     
     get; 
     
     set; }

        
     
     public BuffList()
        {
            ByteList = 
     
     new List<
     
     byte>();
        }

        
     
     public 
     
     void Clecr()
        {
            
     
     lock (locklist)
            {
                ByteList.Clear();
            }
        }

        
     
     public 
     
     void InsertByteArray(
     
     byte[] Data)
        {
            
     
     lock (locklist)
            {
                ByteList.AddRange(Data);
            }
        }

        
     
     public Int16 readint16wgh()
        {
            
     
     byte[] temp = 
     
     new 
     
     byte[
     
     2];
            ByteList.CopyTo(
     
     0, temp, 
     
     0, 
     
     2);
            
     
     return BitConverter.ToInt16(temp, 
     
     0);
        }

        
     
     public 
     
     enum CmdType
        {
            XXX = 
     
     1101,
        }

        
     
     public 
     
     byte[] GetData()
        {
            
     
     lock (locklist)
            {
                
     
     if (ByteList.Count > 
     
     288)
                {
                    
     
     if ((CmdType)readint16wgh() == CmdType.XXX)
                    {
                        
     
     byte[] temp = 
     
     new 
     
     byte[
     
     289];
                        ByteList.CopyTo(
     
     0, temp, 
     
     0, 
     
     289);
                        
     
     if (packet.CheckWGHData(temp))
                        {
                            ByteList.RemoveRange(
     
     0, 
     
     289);
                            
     
     return temp;
                        }
                    }
                    
     
     else
                    {

                        
     
     //
     
     包异常，无法正确解析
     
     
                        
                    }
                    
     
     return 
     
     null;
                }
                
     
     else
                {
                    
     
     return 
     
     null;
                }
            }
        }
    }
bdmh
2011-06-29 12:34:37
建议，把接收和数据处理分开，接收后放到列表中，单独线程对列表逐个处理
hudingwen
2011-06-29 12:39:13
已分开，你看到的这些代码都是接收后委托了另一个线程进行处理的，也就是说我贴出来的代码都是在另一条线程上，但是不一定是一条线程，系统处理不过来时可能会大于一条线程
hudingwen
2011-06-29 13:46:22
哪位兄弟有解决方法呀
djc7811
2011-06-29 13:50:33
引用 1 楼 bdmh 的回复:

建议，把接收和数据处理分开，接收后放到列表中，单独线程对列表逐个处理

接收到数据后，异步处理，你是异步接收的，然后再次加个异步回调处理，我先前就是这样处理的，就没有问题，现在用Delphi开发了，没有那个代码了
hudingwen
2011-06-29 14:03:15
引用 4 楼 djc7811 的回复:
引用 1 楼 bdmh 的回复:

建议，把接收和数据处理分开，接收后放到列表中，单独线程对列表逐个处理

接收到数据后，异步处理，你是异步接收的，然后再次加个异步回调处理，我先前就是这样处理的，就没有问题，现在用Delphi开发了，没有那个代码了

我现在就是异步接收异步回调，关键是我这个缓存机制还是存在线程安全问题，每秒大概100个数据包左右，数据包输入回调是个委托，我记得系统会跟据某些机制开出一条或者更多线程处理这些数据，如果是那样的话，就会有可能多于一条线程进行insert操作，那么就会导致数据包乱序，但是我已加入lock锁，依然有问题
djc7811
2011-06-29 14:13:12
1、发送端发送数据间隔时间长些；
2、接收端用链表接收，边接收边处理数据，接收时Add新数据，处理完毕Delete旧数据
hudingwen
2011-06-29 14:15:26
引用 6 楼 djc7811 的回复:
1、发送端发送数据间隔时间长些；
2、接收端用链表接收，边接收边处理数据，接收时Add新数据，处理完毕Delete旧数据

兄弟，你没看我代码，已是边接收边处理数据，已是接收时add，处理完毕deltete...........关键是我上面说的，线程安全问题
djc7811
2011-06-29 14:17:23
不要加Lock
hudingwen
2011-06-29 14:18:40
引用 8 楼 djc7811 的回复:
不要加Lock

不加lock也会包乱序，我是刚开始没加，出现包乱序，现在加了，仍然包乱序
hudingwen
2011-06-29 14:34:35
哪位兄弟有解决方法呀
hudingwen
2011-06-29 15:07:17
哪位兄弟有解决方法呀
hdw163
2011-06-30 12:43:15
帮顶，望有高手
hudingwen
2011-06-30 13:23:43
我顶呀
FJCfjcFJCfjc
2011-06-30 14:11:12
套接字发送字节流时是根据字节的多少进行多次发送的，所以接收时也要多次接收才行，不然可能有数据丢失问题.
huahua2000
2011-06-30 14:13:12
把你的线程设置为后台线程，处理效率会更快！
hudingwen
2011-06-30 15:35:22
引用 14 楼 fjcfjcfjcfjc 的回复:
套接字发送字节流时是根据字节的多少进行多次发送的，所以接收时也要多次接收才行，不然可能有数据丢失问题.

套接字没丢包，是插缓存时可能由于线程安全问题，导致插包顺序问题，请看前几楼
hudingwen
2011-06-30 16:50:30
引用 15 楼 huahua2000 的回复:
把你的线程设置为后台线程，处理效率会更快！

大哥我需要解决问题的方法。。。
sp1234
2011-06-30 17:06:10
引用 2 楼 hudingwen 的回复:

已分开，你看到的这些代码都是接收后委托了另一个线程进行处理的，也就是说我贴出来的代码都是在另一条线程上，但是不一定是一条线程，系统处理不过来时可能会大于一条线程


你太逗了，这个怎么能“委托了另一个线程进行处理”呢？真是咄咄怪事。我是想不出来，除非你只是为了追时髦，或者你的整个接受代码都是抄别人的。
sp1234
2011-06-30 17:06:58
这也太面向了吧？如果你在另一个线程中处理，你不承担责任吗？
ulihss
2011-06-30 17:10:23
你包乱序是不是因为你的连接是不是断断续续的？？
hudingwen
2011-07-01 01:35:23
引用 18 楼 sp1234 的回复:
引用 2 楼 hudingwen 的回复:

已分开，你看到的这些代码都是接收后委托了另一个线程进行处理的，也就是说我贴出来的代码都是在另一条线程上，但是不一定是一条线程，系统处理不过来时可能会大于一条线程


你太逗了，这个怎么能“委托了另一个线程进行处理”呢？真是咄咄怪事。我是想不出来，除非你只是为了追时髦，或者你的整个接受代码都是抄别人的。

我不知道逗在哪？我也不是什么高手。如果你很高手就直接给出方法好了。

以下是我写的关socket的接收，委托部分，至于抄？微软官方有SocketAsyncEventArgs例子，一步一样自己看

而我帖子的第一段代码就是在InputHandler函数内
C# code 
     
     

        
      
      public 
      
      delegate 
      
      void InputHandler(
      
      byte[] data, SocketAsyncEventArgs socketAsync);

        
      
      public InputHandler Input { 
      
      get; 
      
      set; }

        
      
      void BeginReceive(SocketAsyncEventArgs e)
        {
            
      
      if (e.SocketError == SocketError.Success&&e.BytesTransferred>
      
      0)
            {
                
      
      byte[] data = 
      
      new 
      
      byte[e.BytesTransferred];

                Array.Copy(e.Buffer, e.Offset, data, 
      
      0, data.Length);

                
      
      if (
      
      this.Input != 
      
      null)
                    
      
      this.Input.BeginInvoke(data, e, RecevieCallBack, Input);

                
      
      if (!e.AcceptSocket.ReceiveAsync(e))
                {
                    BeginReceive(e);
                }
            }
         }
hudingwen
2011-07-01 01:40:07
引用 20 楼 ulihss 的回复:
你包乱序是不是因为你的连接是不是断断续续的？？

不是，长连接，局域网内，没断过，包乱序是我观察后得出的结果，不一定正确，但问了一些人，大多数都认为是因为BuffList的线程安全问题。因为我也不确定BeginInvoke(data, e, RecevieCallBack, Input)后是不是一定是单线程。如果不是的话，是否就有可能导致前面的还没写入，后面的先写入了，导致了包乱序。
hudingwen
2011-07-01 01:47:14
引用 19 楼 sp1234 的回复:
这也太面向了吧？如果你在另一个线程中处理，你不承担责任吗？

我不太清楚你所说的承担责任，我理解是socket本身作为主线程时只需负责好握手，收，发这些基本就好，怎么处理收到的数据，和怎么组成数据发出去都应该由其他来处理，以达到最优化，或许是错的，或许是每个人的理解不一样吧
oONukeOo
2011-07-01 09:14:51
你所看到的"掉包"现象实际上是异步调试出现的问题，实际上包的顺序是对的。。。
建议你仔细检查下GetData()函数，再组包的时候是否情况都考虑到了
csnd_freeman
2011-07-01 10:58:14
刚刚开始学习socket，来关注一下。
tyler3180
2011-07-01 16:35:50

 user.BuffList.InsertByteArray(data); //插入数据包缓冲池
加上互斥
类似生产者与消费者问题
hudingwen
2011-07-01 22:28:26
引用 24 楼 oonukeoo 的回复:
你所看到的"掉包"现象实际上是异步调试出现的问题，实际上包的顺序是对的。。。
建议你仔细检查下GetData()函数，再组包的时候是否情况都考虑到了

确实是异步调用出现的问题，是类似多线程读写的问题，就是说insert数据时，有可能有多于一个异步调用，有可能刚好第二条线程先获取了锁先写了进去，如果不用这种异步调用而用阻塞调用，直接BeginReceive中处理是可以解决这个问题，但是这样无论是效率还是本身架构上都显得不合适。
hudingwen
2011-07-01 22:35:47
引用 26 楼 tyler3180 的回复:
user.BuffList.InsertByteArray(data); //插入数据包缓冲池
加上互斥
类似生产者与消费者问题

你是指在使用 user.BuffList.InsertByteArray(data)时互斥？你说的我可以试试，但我觉得不一定行，因为异步调用Input函数时，Input函数本身是否只在一个线程上工作？如果不在是否会互斥？因为这个方式和我在Bufflist内函数加互斥似乎是一样的，我在BuffList.InsertByteArray(data)内部insert时已经加了锁，看代码
C# code 
     
     

 
      
      public 
      
      void InsertByteArray(
      
      byte[] Data)
        {
            
      
      lock (locklist)
            {
                ByteList.AddRange(Data);
            }
        }

按道理来说，如果在需要执行BuffList.InsertByteArray(data)时加锁可以的话，那么当其执行InsertByteArray函数本身时就已经有互斥锁机制了。
hudingwen
2011-07-02 21:42:22
有无高手呀~随便指点指点呀
oONukeOo
2011-07-03 23:57:12
引用 27 楼 hudingwen 的回复:
引用 24 楼 oonukeoo 的回复:
你所看到的"掉包"现象实际上是异步调试出现的问题，实际上包的顺序是对的。。。
建议你仔细检查下GetData()函数，再组包的时候是否情况都考虑到了

确实是异步调用出现的问题，是类似多线程读写的问题，就是说insert数据时，有可能有多于一个异步调用，有可能刚好第二条线程先获取了锁先写了进去，如果不用这种异步调用而用阻塞调用，直接BeginRe……

我们写过类似的代码。。。基本问题都出在处理上而不是想象中的线程问题(我们也是这么猜想的) 后来用了笨办法 在处理过程中添加写LOG 对照LOG测试处理中的问题 如果你还没解决这个问题 建议尝试下
alexccmm
2011-07-04 02:09:49
可能原因、包发太快、n包同时到达
方案一：包与包之间暂停一下下：sleep时间自测罗
方案二：序列化后自己加上包长度、收到包后解出包长度、如果有多的就是下一个包、可就解出下一包、不可就等下一个数据、合包解包、

方案一比较简单
djc7811
2011-07-04 15:19:11
交互模式收发
alexccmm
2011-07-04 15:27:57
发包时断点、看序列化后的大小、
收包后、在断点、看收包后的大小、
看size有没有一样、
过大就是包挤在一块
strife
2011-07-06 09:53:13
看看看看
bei0305
2011-12-04 23:50:03
兄弟你问题解决了吗？
chenandczh
2011-12-05 08:18:22
1.Socket .Accept
判断Socket.Connect
true就接收，结束后到1
false就循环到1
冷月宫主
关注
专栏目录
C语言socket send()数据缓存问题
小鼠标
05-02 4232
send()函数默认情况下会使用Nagle算法，Nagle算法通过将未确认的数据存入缓冲区直到积攒到一定数量一起发送的方法，来减少主机发送零碎小数据包的数目。所以如果send()函数发送数据过快的话，该算法会将一些数据打包后统一发出去。如果不了接这种情况，接收端采会遇到看似很奇怪的问题，比如成功recv()的次数与成功send()的次数不相等，在这中情况下，接收端可以通过recv()的返回值是否为
C#中异步SOCKET发送数据时内存问题
daihongshu的专栏
05-14 4806
做CS的开发一直都是这样的方式： server端用 C++编写，采用IOCP机制处理大量客户端连接、数据接收发送的问题 client端用 C++ 或C# 写，没什么特殊要求。 最近工作时间上比较宽裕，决定采用新的方式来处理服务端的工作： C# + SOCKET异步机制(.net里没有IOCP的直接支持) 目前正可行性分析阶段，第一步的工作：接收3W个SOCKET
举例说明C#异步Socket接收模式下的Socket缓冲区使用
weixin_30924239的博客
01-11 1144
在使用Socket的 异步接收时,需要定义一个对象:/// <summary> /// 传输对象 /// </summary> public class TranslateObj {/// <summary>/// 缓冲区/// </summary>public byte[] bytes;/// <summary>...
C# 异步Socket
weixin_33766168的博客
08-06 108
先看看测试结果：服务端：服务器端控制台：可以发现我服务端连了2个客户端，第一个为局域网的一台机器，另一个为服务器的主机ip为192.168.1.105 ，端口为42794的客户端：ip为192.168.1.104,端口为30547的客户端：需要发送聊天信息 ： 使用“chat:”作为前缀。值得注意的是 ： 本文只探讨异步Socket的封装 ， 包括包头和包 。对与体验效果不好...
Socket接收字节缓冲区
wyd1520的专栏
04-16 1万+
我们接收Socket字节流数据一般都会定义 如   协议号  长度  内容 这三个
linux tcp socket的发送与接收缓冲区
jhfeng2002的专栏
04-07 1万+
<br />  应用程序可通过调用send(write, sendmsg等)利用tcp socket向网络发送应用数据，而tcp/ip协议栈再通过网络设备接口把已经组织成struct sk_buff的应用数据(tcp数据报)真正发送到网络上，由于应用程序调用send的速度跟网络介质发送数据的速度存在差异，所以，一部分应用数据被组织成tcp数据报之后，会缓存在tcp socket的发送缓存队列中，等待网络空闲时再发送出去。同时，tcp协议要求对端在收到tcp数据报后，要对其序号进行ACK，只有当收到一个tcp
linux 内核socket相关数据结构介绍
最新发布
02-21
### Linux 内核 Socket 相关数据结构介绍 #### 一、引言 在 Linux 内核中，网络通信的核心是 Socket。为了更好地理解和掌握 Socket 的工作原理与内部机制，了解其相关的数据结构至关重要。本文将详细介绍 Linux ...
基于TCP的多线程异步socket通信
fazstyle的博客
04-09 1759
基于TCP的多线程异步socket通信 1、服务端使用socket流程： 1）加载套接字库：WSAStartup （后面要给出具体函数的说明） //加载套接字库 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD(2, 2); //表示调用版本2.2 wVersionRequested结...
NET_Source.rar_Detect Object_事件 异步_是否分包_高性能大容量SOCKET并发
09-23
m_asyncReceiveBuffer接收数据异步事件使 用的缓存；m_sendEventArgs发送数据异步事件；m_receiveBuffer接收异步事件返回的数据存放缓存，用于后续的分 包；m_sendBuffer用于保存发送的数据缓存；m_...
socket的异步通讯机制
weixin_46921682的博客
10-28 2540
前言： 在网络socket编程中，开发着常常没有异步通讯的经验，客户端发完数据就阻塞等待，或者开启一个进程或线程来专门处理 通讯问题。很少有人能写出一个异步通讯的优雅流程，从而适应当前大规模平行计算的要求。我想就这个问题以FTP为例和大家分享一下。 问题： FTP 是一个建立在TCP/IP之上，在客户端和服务器之间用于文件传输的标准协议。要实现一个完整的客户端文件下载过程，一般有三个步骤： 通过三次握手建立TCP的控制信道，然后发送用户名和密码，通过用户认证；还需要指定下载文件的模式和接收建立数据信道传输
深入socket底层（一）（缓冲区问题）
二的十六次方的博客
02-12 4491
本文演示的代码是我之前使用的一段socket的简单服务端和客户端代码，详情点击 进行了一些修改，把缓冲区进行一些改变 服务端把缓冲区设置为10个字节： msg=self.request.recv(10)#10为buffsize 客户端也设置为10： re=client.recv(10) 客户端发送大于10字节的数据，会如何处理？？？？ 下面客户端发什么数据给服务端，服务端就...
多线程+socket+文件读写<二>
itcast123的专栏
07-26 240
线程的阻塞阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），Java 提供了大量方法来支持阻塞，下面让我们逐一分析。    1. sleep() 方法：sleep() 允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。    2. suspend() 和 resume() 方法：两个方法配套使用...
socket收发缓冲区
ldw662523的博客
03-13 1万+
1. TCP socket的接收和发送缓冲区: socket(PF_INET, SOCK_STREAM, 0); 每个TCP Socket在内核中都有一个发送缓冲区和一个接收缓冲区， TCP的全双工工作模式以及TCP的滑动窗口就是依赖这两个独立的buffer以及buffer的填充状态。 应用程序调用write()或send()时，仅仅是把应用程序buffer中的数据copy到socket的...
C# Socket的TCP通讯
CL1250887989的博客
06-03 1219
Socket的TCP通讯 一、 socket的通讯原理 服务器端的步骤如下。 （1）建立服务器端的Socket，开始侦听整个网络中的连接请求。 （2）当检测到来自客户端的连接请求时，向客户端发送收到连接请求的信息，并建立与客户端之间的连接。 （3）当完成通信后，服务器关闭与客户端的Socket连接。 客户端的步骤如下。 （1）建立客户端的Socket，确定要连接的服务器的主...
C#高性能大容量SOCKET并发（四）：缓存设计
热门推荐
SQLDebug_Fan的专栏
03-05 2万+
在编写服务端大并发的应用程序，需要非常注意缓存设计，缓存的设计是一个折衷的结果，需要通过并发测试反复验证。有很多服务程序是在启动时申请足够的内存空间，避免在运行期间再申请空间，这种是固定空间申请。还有一种是在运行期间动态增长的缓存设计，随着运行动态申请内存，这种事动态空间申请。这两种机制各有优劣，固定空间申请优点是效率高，运行稳定，缺点是对应用场景具有限制；动态空间申请优点是能适应更好的应用场景，缺点是效率相对低一些，并发数降一些；这种性能下降不是太明显，毕竟申请释放内存的效率NET是有优化的，具体需要根据
TCP通信socket缓存读取阻塞
杨道福的博客
07-12 3155
tcp通信——socket缓存读取阻塞 TCP通信过程，主要是数据的收发，最近一直在学习这方面的知识，其中有很多的细节部分确实是没有接触到，即便是一个小小的知识点，也会导致编程半天没有进展，需要查找很多的资料来解决这方面的问题，以下就来谈谈我在编程中所遇到的问题： tcp通信程序，包括服务器和客户端，程序编写完成后就会问题，调试的时候。我要进行的工作是把单片机当做服务器，计算机当做客户端来
[转]socket编程与线程模型
学海无涯
09-15 1438
这里线程模型是指winsock相关的线程模型设计。　　在本软件的设计的过程中有些问题是涉及到winsock的问题，为了能够很好的设计线程模型，必须理解清楚socket的内部工作机制。为此，首先从外面开始分析。　　一、为什么使用多线程　　1、使用多线程是为了避免应用程序主界面在I/O操作中没有反应，出现假死机现象。　　Socket是一种特殊的I/O，所以很可能会出现这种现象。例如发送
对Socket CAN的理解（4）——【Socket CAN接收数据流程】
u014286440的博客
11-02 1442
转载请注明出处：http://blog.csdn.net/Righthek 谢谢！           现在我们来分析一下CAN总线的接收数据流程，对于网络设备，数据接收大体上采用中断+NAPI机制进行数据的接收。同样，我们现在的CAN模块也是采用同样的方式进行数据的接收。由于我们只针对CAN总线接收数据这条主线进行分析。因些，会忽略一些针对CAN协议的...
socketcan使用
weixin_41536412的博客
10-10 474
sockecan不能发送太快
提升SOCKET并发性能的异步事件管理技术
1. m_receiveEventArgs：用于接收数据的异步事件，它允许服务器在不阻塞主线程的情况下处理数据接收。 2. m_asyncReceiveBuffer：是接收数据异步事件使用的缓存，用于暂存接收到的数据，直到应用层处理。 3. m_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值