C#中异步SOCKET发送数据时内存问题

来源：互联网发布：深圳市信诚网络编辑：程序博客网时间：2024/05/17 22:08

做CS的开发一直都是这样的方式：

server端用 C++编写，采用IOCP机制处理大量客户端连接、数据接收发送的问题

client端用 C++ 或C# 写，没什么特殊要求。

最近工作时间上比较宽裕，决定采用新的方式来处理服务端的工作： C# + SOCKET异步机制(.net里没有IOCP的直接支持)

目前正可行性分析阶段，第一步的工作：接收3W个SOCKET连接，结果还是不错的，很快就建立起来了，速度也可以。

但是第二步测试，接收、发送数据时，就发生了点问题：

运行的SERVER程序在较短的时间内就占用了大量的内存！

我的测试环境：i3 +2G内存 + Win732位

客户端创建5000个连接，每间隔1秒种对所有的连接发送、接收一次数据。每次发送20bytes到server。

服务端与客户端不在同一台机器上

一般情况下，程序的启动内存占用为4.5M ，运行5分钟后，SERVER程序内存占用超过 100M，并且还在不停的快速增长

在一台服务器上测试(2W个连接)，4个小时内，把8G内存全部用光（从任务管理器上看，使用了7.9G内存）

先看SERVER端的完整代码：(大家可以COPY到自己的IDE里直接编译)

[csharp] view plaincopy
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Net.Sockets;  
  
namespace TestAsyncSendMem  
{  
    class Program  
    {  
        static TcpListener m_lisnter;  
        static AsyncCallback m_acb = new AsyncCallback(DoAcceptSocketCallback);  
        static void Main(string[] args)  
        {  
            m_lisnter = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Any, 8001);  
            m_lisnter.Start(5 * 1000);  
  
            try  
            {  
                m_lisnter.BeginAcceptSocket(m_acb, null);  
            }  
            catch (Exception ex)  
            {  
                m_lisnter.Stop();  
                m_lisnter = null;  
  
                System.Diagnostics.Debug.WriteLine("BeginAcceptSocket err.Start fail!" + ex);  
                return;  
            }  
            Console.WriteLine("Begin receiving connection... Press any key to quit.");  
  
            Console.ReadKey();  
  
            m_lisnter.Stop();  
        }  
  
        static void DoAcceptSocketCallback(IAsyncResult ar)  
        {  
            System.Net.Sockets.Socket s = null;  
            try  
            {  
                s = m_lisnter.EndAcceptSocket(ar);  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("End Accept socket err" + ex);  
                s = null;  
            }  
  
            try  
            {  
                m_lisnter.BeginAcceptSocket(m_acb, null);  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("after accept client socket,Re beginAcceptSocket fail." + ex);  
            }  
  
            if (s != null)  
            {  
                #region...  
                CTcpClientSync c = new CTcpClientSync(s);  
                Console.WriteLine(string.Format("accept client.{0}", c.Socket.RemoteEndPoint));  
  
                if (c.BeginRcv() == true)  
                {  
                    c.OnDisconnected += (CTcpClientSync client) =>  
                    {  
                        System.Diagnostics.Debug.WriteLine(string.Format("client {0} disconected", client.RemoteIP));  
                    };  
                }  
                else  
                {  
                    c.Stop();  
                    System.Diagnostics.Debug.WriteLine(string.Format("accepted client {0} removed.cannot begin rcv", c.RemoteIP));  
                }  
                #endregion  
            }  
  
        }  
    }  
  
    public class CTcpClientSync  
    {  
        #region delegate  
  
        public delegate void dlgtDisconnected(CTcpClientSync c);  
        public event dlgtDisconnected OnDisconnected;  
 
        #endregion  
 
        #region prop  
  
        Socket m_skt = null;  
        public Socket Socket { get { return m_skt; } }  
  
        string m_strRemoteIP;  
        public string RemoteIP { get { return m_strRemoteIP; } }  
  
        byte[] m_arybytBuf = new byte[1024];  
  
        AsyncCallback m_acb = null;  
 
        #endregion  
  
        public CTcpClientSync(Socket skt)  
        {  
            m_acb = new AsyncCallback(DoBeginRcvData);  
  
            m_skt = skt;  
            try  
            {  
                m_strRemoteIP = skt.RemoteEndPoint.ToString();  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("get remote end point exception."+ ex);  
            }  
  
        }  
  
        public void Stop()  
        {  
            m_skt.Close();  
        }  
 
        #region Raise event  
        void RaiseDisconnectedEvent()  
        {  
            dlgtDisconnected handler = OnDisconnected;  
            if (handler != null)  
            {  
                try  
                {  
                    handler(this);  
                }  
                catch (Exception ex)  
                {  
                    System.Diagnostics.Debug.WriteLine("Raise disconn event exception." + ex.Message);  
                }  
            }  
        }  
        #endregion  
  
        public bool BeginRcv()  
        {  
            try  
            {  
                m_skt.BeginReceive(m_arybytBuf, 0, m_arybytBuf.Length, SocketFlags.None, m_acb, null);  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("BeginRcv exception." + ex);  
                return false;  
            }  
  
            return true;  
        }  
  
        void DoBeginRcvData(IAsyncResult ar)  
        {  
            int iReaded = 0;  
            try  
            {  
                iReaded = m_skt.EndReceive(ar);  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("BeginRcv exception." + ex);  
  
                Stop();  
                RaiseDisconnectedEvent();  
  
                return;  
            }  
  
            if (iReaded > 0)  
            {  
                //收到后发送回一个数据包  
                SendAsync(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });  
  
                if (BeginRcv() == false)  
                {  
                    Stop();  
                    RaiseDisconnectedEvent();  
                }  
            }  
            else  
            {  
                Stop();  
                RaiseDisconnectedEvent();  
            }  
        }  
  
        public bool SendAsync(byte[] bytsCmd)  
        {  
            SocketAsyncEventArgs e = new SocketAsyncEventArgs();  
            try  
            {  
                e.SetBuffer(bytsCmd, 0, bytsCmd.Length);  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("SetBuffer exception." + ex);  
                return false;  
            }              
  
            try  
            {  
                if (m_skt.SendAsync(e))  
                {//Returns true if the I/O operation is pending.  
                    return true;  
                }  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("SendAsync exception." + ex);                  
  
                return false;  
            }  
  
            //Returns false if the I/O operation completed synchronously.   
            //In this case, The SocketAsyncEventArgs.Completed event on the e parameter will not be raised and   
            //the e object passed as a parameter may be examined immediately after the method call returns to retrieve the result of the operation.  
  
            return true;  
  
        }  
    }  
}  

.net中的内存是由系统自行回收的，一旦一个对象（内存块）发现没有被其它任何人使用（引用）则会被回收。

当满足以下条件之一时将发生垃圾回收：

The system has low physical memory.
The memory that is used by allocated objects on the managed heap surpasses an acceptable threshold. This means that a threshold of acceptable memory usage has been exceeded on the managed heap.This threshold is continuously adjusted as the process runs.
The GC.Collect method is called. In almost all cases, you do not have to call this method, because the garbage collector runs continuously. This method is primarily used for unique situations and testing.

具体请看这里（垃圾回收）

条件1：当物理内存极低时会调用

如上所说，我在一个服务器上测试此程序，8G内存，2W个连接，每5秒种给所有的连接发送一次。在大概4个小时就把所有的内存完了。从任务管理器上看，内存占用了7.9个G。并且，此时SERVER程序已经无法接受发送来自客户端的数据了。所以，按这个情况，内存回收肯定应该工作了！但没有！

条件2：已经在托管heap上分配的对象所占用的内存超过一个阀值时会调用。这个阀值会动态变更。

如上一个测试，物理内存都已经用光了，并导致程序不能正常运行了。这个阀值还没有超过？！！这个阀值是怎么定的呢？（需要找一下文档，网友了解的提供一下 :)）

假定是因为某种原因，GC没有执行。那我们手动的执行一下，添加一个全局变量 s_iRcvTimes ，每接收5000次就执行一下回收

[csharp] view plaincopy
public bool SendAsync(byte[] bytsCmd)  
{  
    if (s_iRcvTimes > 5000)  
    {  
        s_iRcvTimes = 0;  
        GC.Collect(2);  
    }  
    s_iRcvTimes += 1;  

[csharp] view plaincopy
...//原来的代码省略  

测试结果如下：(程序启动后，每过一段时间记录一下SERVER程序的内存占用情况)

程序的启动内存占用为：4.5M

序号时间时间间隔内存占用内存增长116:07:001分钟22,023K－－216:08:001分钟22,900K 677K316:10:002分钟26,132K 3,232K416:12:002分钟30,172K 4,040K516:17:005分钟116,032K 85,860K616:22:005分钟200,146K 84,114K716:27:005分钟274,120K 73,974K

内存占用：对应时刻Server程序所占用的内存（从windows任务管理器看到的数据）

从测试结果来看，应该没有起到作用！

我感觉，还是程序有问题！理论上来说，一旦内存不够，则系统自动进行回收，但是，为什么这里的情况不进行回收呢？！！MSDN里有这样一句话：

When a garbage collection is triggered, the garbage collector reclaims the memory that is occupied by dead objects.

所以，有可能有些对象根本都没有成为 dead objects，从而使GC没办法将其回收。

OK ，那先找到内存爆涨的地方，再来分析为什么这些对象没办法成为 dead object ！

内存出问题，那肯定是NEW出来的没有被回收！

程序中，NEW的地方有几个：

1.收到数据后，回送的地方：SendAsync(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });

2.接收数据里的异步操作支持：SocketAsyncEventArgs e = new SocketAsyncEventArgs();

下意识的觉得第二个地方比较可疑。所以，修改此处并测试。内存果然有明显的提升：

两个测试：

1. 5K个连接，每次给每个连接发送20个bytes，发完后停止1秒再继续。

2. 1K个连接，每次给每个连接发送20个bytes，发完后停止1秒再继续。

测试的结果，可以坚持10分钟以上没有任何问题，这期间内存一直在30M以下，启动后当所有的连接连上来之后（开始发送数据之前）程序大概占用20M

其实MSDN里也有对这个的例子，例子中对这个 SocketAsyncEventArgs也是给缓存起来，而不是直接每次都NEW一个对象。它的例子详细请看这里

修改后的代码如下：添加一个变量

[csharp] view plaincopy
public static List<SocketAsyncEventArgs> s_lst = new List<SocketAsyncEventArgs>();  

然后修改SendAsync 函数如下：

[csharp] view plaincopy
    
public bool SendAsync(byte[] bytsCmd)  
        {  
              SocketAsyncEventArgs e = null;//new SocketAsyncEventArgs();  
            lock (Program.s_lst)  
            {  
                if (Program.s_lst.Count > 0)  
                {  
                    e = Program.s_lst[Program.s_lst.Count - 1];  
                    Program.s_lst.RemoveAt(Program.s_lst.Count - 1);  
                }  
            }  
            if (e == null)  
            {  
                e = new SocketAsyncEventArgs();  
                e.Completed += (object sender, SocketAsyncEventArgs _e) =>  
                {  
                    lock (Program.s_lst)  
                        Program.s_lst.Add(e);  
                };  
            }   
  
            try  
            {  
                e.SetBuffer(bytsCmd, 0, bytsCmd.Length);  
            }  
            catch (Exception ex)  
            {  
                lock (Program.s_lst)  
                    Program.s_lst.Add(e);  
                System.Diagnostics.Debug.WriteLine("SetBuffer exception." + ex);  
                return false;  
            }  
  
            try  
            {  
                if (m_skt.SendAsync(e))  
                {//Returns true if the I/O operation is pending.  
                    return true;  
                }  
            }  
            catch (Exception ex)  
            {  
                System.Diagnostics.Debug.WriteLine("SendAsync exception." + ex);                  
  
                return false;  
            }  
  
            //Returns false if the I/O operation completed synchronously.   
            //In this case, The SocketAsyncEventArgs.Completed event on the e parameter will not be raised and   
            //the e object passed as a parameter may be examined immediately after the method call returns to retrieve the result of the operation.  
            lock (Program.s_lst)  
                Program.s_lst.Add(e);  
            return true;  
  
        }   

方法应该比较简单：不是每次都创建新的对象，而是用完后保存起来给下次调用时使用。

基本上我们可以认为发送数据的那一部分中有问题：每一次发送，有两个NEW的动作，产生两个新的对象。现在问题的关键是：为什么这两个新的对象没办法被回收！我们先做一实验，代码如下：

[csharp] view plaincopy
namespace Test2  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Console.WriteLine("Press any key to start.");  
            Console.ReadKey();  
  
            for (int i = 0; i < 1000000; ++i)  
            {  
                for (int j = 0; j < 10000; ++j)  
                {  
                    SocketAsyncEventArgs e = new SocketAsyncEventArgs();  
                }  
                System.Threading.Thread.Sleep(1000);  
            }  
        }  
    }  
}  

观察了几次，每次5分钟左右，内存波动范围：

最低：8,512K

最高：13,516K

内存不是固定在某个值，而是在这个区间内不停的变动，而且幅度比较大。估计是内存增长到一定的范围（上一章说的那个阀值？）就自动进行回收了，所以，内存马上又下降，从而使得我们看到内存在不停的波动。

现在我们每次得到10000个对象之后，就手动处理一下内存回收，看什么结果，代码改为这样:

[csharp] view plaincopy
for (int i = 0; i < 1000000; ++i)    
{    
    for (int j = 0; j < 10000; ++j)    
    {    
        SocketAsyncEventArgs e = new SocketAsyncEventArgs();    
    }    
    GC.Collect(2);  
    System.Threading.Thread.Sleep(1000);    
}    

最低：8992

最高：10608

内存看起来（至少在我的机器上试了几次）稳定多了，变动的幅度也相比小一些，甚至有一会一直在（9800K-9900K）两个数字之间变化

上面的两个实验可能不是很准确，我的大概的意图是了解一下回收的效果，也可以让大家大概了解一下。

现在我们继续这个实验，当然要结合我上一文章的例子。代码如下：

[csharp] view plaincopy
namespace Test2  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Console.WriteLine("Press any key to start.");  
            Console.ReadKey();  
  
            for (int i = 0; i < 1000000; ++i)  
            {  
                for (int j = 0; j < 10000; ++j)  
                {  
                    SocketAsyncEventArgs e = new SocketAsyncEventArgs();  
                    e.SetBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 }, 0, 10);  
                }  
                GC.Collect();  
                System.Threading.Thread.Sleep(1000);  
            }  
        }  
    }  
}  

这里把上一篇文章中的两个NEW动作都包含进来了，测试了一下，几乎是在几十秒内内存增长了60多M！

OK，问题就是出在这里了。

这里有一个明显的疑点：为什么加了这个SetBuffer 之后，内存的需求量就开始暴增呢？难道是这里new出来的byte数组没有被释放？从而导致两个新创建的对象都无法成为 dead object ？

修改代码如下：

[csharp] view plaincopy
for (int i = 0; i < 1000000; ++i)  
{  
    for (int j = 0; j < 10000; ++j)  
    {  
        SocketAsyncEventArgs e = new SocketAsyncEventArgs();  
        e.SetBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 }, 0, 10);  
  
        <em>e.SetBuffer(null, 0, 0)</em>;  
    }  
    GC.Collect();  
    System.Threading.Thread.Sleep(1000);  
}  

测试了一下，非常正确，内存稳定了~~~

现在根据这个发现去修改上一文章中的例子，每次发送完数据就取消SocketAsyncEventArgs 对 byte数组的引用。代码如下：

[csharp] view plaincopy
public bool SendAsync(byte[] bytsCmd)  
{  
    //下面5行为新增加、修改的行  
    SocketAsyncEventArgs e = new SocketAsyncEventArgs();  
    e.Completed += (object s, SocketAsyncEventArgs _e) =>  
    {  
        e.SetBuffer(null, 0, 0);  
    };  
  
    try  
    {  
        e.SetBuffer(bytsCmd, 0, bytsCmd.Length);  
    }  
    catch (Exception ex)  
    {  
        lock (Program.s_lst)  
            Program.s_lst.Add(e);  
        System.Diagnostics.Debug.WriteLine("SetBuffer exception." + ex);  
        return false;  
    }  
  
    try  
    {  
        if (m_skt.SendAsync(e))  
        {//Returns true if the I/O operation is pending.  
            return true;  
        }  
    }  
    catch (Exception ex)  
    {  
        System.Diagnostics.Debug.WriteLine("SendAsync exception." + ex);                  
  
        return false;  
    }  
  
    e.SetBuffer(null, 0, 0);//新增加的行  
  
    return true;  
}  

上面的代码还是按最初的方式处理：发送一次数据生成一个SocketAsyncEventArgs对象，但是，为了能使GC能正确的回收，在命令完成后，我们增加了e.SetBuffer(null,0,0) 这一句，以表明这几个对象都不用了，已经是 dead objects 了！

修改完后的代码测试了20分钟，内存一直稳定在30M左右！

结论：

GC不是我们想象的那样聪明！两个dead object如果互相引用，它就没办法判断是否应该回收了！所以，用.net编程时，也要小心内存的处理，时刻要为GC着想、帮它一把！:)

0 0