接受多个 tcp 客户端的最佳方式？

Question

我有一个客户端/服务器基础设施。 目前他们使用 TcpClient 和 TcpListener 在所有客户端和服务器之间发送接收数据。

我目前所做的是当接收到数据时（在它自己的线程上），它被放入一个队列中供另一个线程处理以释放套接字，以便它准备好并打开以接收新数据。

                // Enter the listening loop.
                while (true)
                {
                    Debug.WriteLine("Waiting for a connection... ");

                    // Perform a blocking call to accept requests.
                    using (client = server.AcceptTcpClient())
                    {
                        data = new List<byte>();

                        // Get a stream object for reading and writing
                        using (NetworkStream stream = client.GetStream())
                        {
                            // Loop to receive all the data sent by the client.
                            int length;

                            while ((length = stream.Read(bytes, 0, bytes.Length)) != 0)
                            {
                                var copy = new byte[length];
                                Array.Copy(bytes, 0, copy, 0, length);
                                data.AddRange(copy);
                            }
                        }
                    }

                    receivedQueue.Add(data);
                }

但是我想知道是否有更好的方法来做到这一点。 例如，如果有 10 个客户端，并且他们都想同时向服务器发送数据，则其中一个会通过，而所有其他客户端都将失败。或者，如果一个客户端的连接速度很慢并占用了套接字，则所有其他通信都将停止.

有没有什么办法可以同时从所有客户端接收数据，并在下载完成后将接收到的数据添加到队列中进行处理？

Answer 1

所以这里有一个可以帮助您入门的答案 - 这比我的博客文章更初级。

.Net 有一个围绕 Begin* 和 End* 调用的异步模式。 例如 - BeginReceive和EndReceive 。 它们几乎总是有它们的非异步对应物（在本例中为Receive ）； 并实现完全相同的目标。

要记住的最重要的事情是套接字的作用不仅仅是使调用异步 - 它们公开了称为 IOCP（IO 完成端口，Linux/Mono 有这两个但我忘记了名称）的东西，这对于在服务器; IOCP 所做的关键是您的应用程序在等待数据时不消耗线程。

如何使用开始/结束模式

每个 Begin* 方法与它的非异步对应方法相比，将有 2 个以上的参数。 第一个是 AsyncCallback，第二个是一个对象。 这两个的意思是，“这是一个完成后调用的方法”和“这是我需要在该方法中使用的一些数据”。 被调用的方法总是具有相同的签名，在这个方法中，你调用 End* 对应的方法来获得如果你同步完成会得到的结果。 例如：

private void BeginReceiveBuffer()
{
   _socket.BeginReceive(buffer, 0, buffer.Length, BufferEndReceive, buffer);
}

private void EndReceiveBuffer(IAsyncResult state)
{
   var buffer = (byte[])state.AsyncState; // This is the last parameter.
   var length = _socket.EndReceive(state); // This is the return value of the method call.
   DataReceived(buffer, 0, length); // Do something with the data.
}

这里发生的是净将立即开始，因为它得到的数据调用等待数据从插座， EndReceiveBuffer并通过“自定义数据”（在这种情况下buffer经）将其state.AsyncResult 。 当您调用EndReceive它会返回接收到的数据的长度（如果出现故障则抛出异常）。

更好的套接字模式

这种形式将为您提供中央错误处理——它可以在异步模式包装类似流的“事物”的任何地方使用（例如，TCP 按照发送的顺序到达，因此可以将其视为Stream对象）。

private Socket _socket;
private ArraySegment<byte> _buffer;
public void StartReceive()
{
    ReceiveAsyncLoop(null);
}

// Note that this method is not guaranteed (in fact
// unlikely) to remain on a single thread across
// async invocations.
private void ReceiveAsyncLoop(IAsyncResult result)
{
    try
    {
        // This only gets called once - via StartReceive()
        if (result != null)
        {
            int numberOfBytesRead = _socket.EndReceive(result);
            if(numberOfBytesRead == 0)
            {
                OnDisconnected(null); // 'null' being the exception. The client disconnected normally in this case.
                return;
            }

            var newSegment = new ArraySegment<byte>(_buffer.Array, _buffer.Offset, numberOfBytesRead);
            // This method needs its own error handling. Don't let it throw exceptions unless you
            // want to disconnect the client.
            OnDataReceived(newSegment);
        }

        // Because of this method call, it's as though we are creating a 'while' loop.
        // However this is called an async loop, but you can see it the same way.
        _socket.BeginReceive(_buffer.Array, _buffer.Offset, _buffer.Count, SocketFlags.None, ReceiveAsyncLoop, null);
    }
    catch (Exception ex)
    {
        // Socket error handling here.
    }
}

接受多个连接

您通常做的是编写一个包含您的套接字等（以及您的异步循环）的类，并为每个客户端创建一个。 所以例如：

public class InboundConnection
{
    private Socket _socket;
    private ArraySegment<byte> _buffer;

    public InboundConnection(Socket clientSocket)
    {
        _socket = clientSocket;
        _buffer = new ArraySegment<byte>(new byte[4096], 0, 4096);
        StartReceive(); // Start the read async loop.
    }

    private void StartReceive() ...
    private void ReceiveAsyncLoop() ...
    private void OnDataReceived() ...
}

每个客户端连接都应该由您的服务器类跟踪（这样您可以在服务器关闭时干净地断开它们，以及搜索/查找它们）。

Answer 2

您应该使用异步读取数据的方法，例如：

// Enter the listening loop.
while (true)
{
    Debug.WriteLine("Waiting for a connection... ");

    client = server.AcceptTcpClient();

    ThreadPool.QueueUserWorkItem(new WaitCallback(HandleTcp), client);
}

private void HandleTcp(object tcpClientObject)
{
    TcpClient client = (TcpClient)tcpClientObject;
    // Perform a blocking call to accept requests.

    data = new List<byte>();

    // Get a stream object for reading and writing
    using (NetworkStream stream = client.GetStream())
    {
        // Loop to receive all the data sent by the client.
        int length;

        while ((length = stream.Read(bytes, 0, bytes.Length)) != 0)
        {
            var copy = new byte[length];
            Array.Copy(bytes, 0, copy, 0, length);
            data.AddRange(copy);
        }
    }

    receivedQueue.Add(data);
} 

此外，您应该考虑使用AutoResetEvent或ManualResetEvent在新数据添加到集合时收到通知，以便处理数据的线程知道何时接收到数据，如果您使用4.0您最好关闭使用BlockingCollection而不是Queue 。

Answer 3

您应该使用异步套接字编程来实现这一点。 看一下 MSDN 提供的示例。

Answer 4

我通常做的是使用具有多个线程的线程池。 在每个新连接上，我都在池中的一个线程中运行连接处理（在您的情况下 - 您在 using 子句中所做的一切）。

通过这种方式，您可以同时实现两个性能，因为您允许多个同时接受的连接，并且还限制了为处理传入连接分配的资源（线程等）数量。

你在这里有一个很好的例子

祝你好运