使用 System.Net.Sockets.Socket.AcceptAsync 模型时的堆栈溢出

Question

对于 C# 和 .NET 的 System.Net.Sockets.Socket.AcceptAsync 方法，需要处理“false”的返回值，以便从同步处理的连接中处理立即可用的 SocketAsyncEventArgs 状态。 Microsoft 提供了示例（在System.Net.Sockets.SocketAsyncEventArgs 类页面上找到），如果存在大量未决连接，将导致堆栈溢出，这可以在任何实现其处理模型的系统上被利用。

解决此问题的其他想法是创建一个调用处理程序方法的循环，条件是 Socket.AcceptAsync 返回的值等于 false，如果value 表示操作正在异步完成（true）。但是，这个解决方案也会导致堆栈溢出漏洞，因为与传递给Socket.AcceptAsync 的SocketAsyncEventArgs 关联的回调在方法的末尾有一个对Socket.AcceptAsync 的调用，它也有一个立即执行的循环可用的、同步接受的连接。

如您所见，这是一个非常可靠的问题，我还没有找到一个不涉及System.Threading.ThreadPool 和创建大量其他方法和调度处理的好解决方案。据我所知，与Socket.AcceptAsync 相关的异步套接字模型需要的不仅仅是 MSDN 上的示例中演示的内容。

有没有人有一个干净有效的解决方案来处理从 Socket.AcceptAsync 同步接受的立即挂起的连接，而无需创建单独的线程来处理连接并且不使用递归？

Answer 1

我不会使用AcceptAsync，而是使用BeginAccept/EndAccept，并正确实现常见的异步模式，即检查CompletedSynchronously以避免在回调线程中对完成的操作进行回调。

另见AsyncCallBack CompletedSynchronously

---

修改使用AcceptAsync的要求：

MSDN documentation 明确表示不会为同步完成的操作调用回调。这与总是调用回调的常见异步模式不同。

如果 I/O 操作是，则返回 true 待办的。这 SocketAsyncEventArgs.Completed 事件 在 e 参数将被提出 操作的完成。退货 如果 I/O 操作完成，则返回 false 同步。这 SocketAsyncEventArgs.Completed 事件 在 e 参数上不会被提升 和作为参数传递的 e 对象 后可立即检查 方法调用返回以检索 运算结果。

我目前看不出循环如何解决堆栈溢出问题。也许您可以更具体地说明导致问题的代码？

---

编辑 2：我正在考虑这样的代码（仅针对 AcceptAsync，其余的只是为了获得一个可以运行的应用程序来试用它）：

static void Main(string[] args) {
    Socket listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 4444));
    listenSocket.Listen(100);
    SocketAsyncEventArgs e = new SocketAsyncEventArgs();
    e.Completed += AcceptCallback;
    if (!listenSocket.AcceptAsync(e)) {
        AcceptCallback(listenSocket, e);
    }
    Console.ReadKey(true);
}

private static void AcceptCallback(object sender, SocketAsyncEventArgs e) {
    Socket listenSocket = (Socket)sender;
    do {
        try {
            Socket newSocket = e.AcceptSocket;
            Debug.Assert(newSocket != null);
            // do your magic here with the new socket
            newSocket.Send(Encoding.ASCII.GetBytes("Hello socket!"));
            newSocket.Disconnect(false);
            newSocket.Close();
        } catch {
            // handle any exceptions here;
        } finally {
            e.AcceptSocket = null; // to enable reuse
        }
    } while (!listenSocket.AcceptAsync(e));
}

Answer 2

我通过简单地改变循环的位置解决了这个问题。不是从自身内部递归调用接受处理程序，而是将代码包装在一个 do-while 循环中，条件为“！Socket.AcceptAsync(args)”可以防止堆栈溢出。

这背后的原因是您利用回调线程来处理立即可用的连接，然后再费心异步等待其他连接出现。它有效地重用了一个池线程。

我很欣赏这些回复，但由于某种原因，他们都没有点击我，也没有真正解决问题。然而，似乎里面有什么东西让我想到了这个主意。它避免了手动使用 ThreadPool 类并且不使用递归。

当然，如果有人有更好的解决方案甚至替代方案，我很乐意听到。

Answer 3

我没有仔细看，但闻起来可能会有所帮助（请参阅名为“堆栈潜水”的部分）：

http://blogs.msdn.com/b/mjm/archive/2005/05/04/414793.aspx

Answer 4

newSocket.Send(Encoding.ASCII.GetBytes("Hello socket!")); 
newSocket.Disconnect(false); 
newSocket.Close(); 

上面这个sn-p的问题是这会阻塞你的下一个accept操作。

更好的方法是这样的：

while (true)
{
   if (e.SocketError == SocketError.Success)
   {
      //ReadEventArg object user token
      SocketAsyncEventArgs readEventArgs = m_readWritePool.Pop();
      Socket socket = ((AsyncUserToken)readEventArgs.UserToken).Socket = e.AcceptSocket;

      if (!socket.ReceiveAsync(readEventArgs))
         ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessReceiveEx), readEventArgs); .
    }
    else
    {
       HadleBadAccept(e);
    }

    e.AcceptSocket = null;

    m_maxNumberAcceptedClients.WaitOne();
    if (listenSocket.AcceptAsync(e))
       break;
}