Question

我正在构建一个接受传入TCP连接的服务器应用程序。（大约300个唯一客户）。请注意，我无法控制客户。

我发现一些连接客户端在建立初始连接并发送第一个状态更新后保持空闲一段时间。当它们闲置5分钟以上时，应用程序的CPU使用率将跃升至90％以上并保持不变。

为解决此问题，我内置了一个4分钟后触发的取消令牌。这使我可以终止连接。然后，客户端检测到此情况，大约一分钟后重新连接。这解决了CPU使用率高的问题，但是具有高内存使用率的副作用，似乎存在内存泄漏。我怀疑资源是由先前的套接字对象保存的。

我有一个客户端对象，其中包含套接字连接和有关已连接客户端的信息。它还管理传入的消息。还有一个经理类，它接受传入的连接。然后，它创建客户端对象，为其分配套接字，并将客户端对象添加到并发字典中。每隔10秒钟，它将检查字典中是否有已设置为_closeConnection = true的客户端，并调用其dispose方法。

以下是一些客户端对象代码：

public void StartCommunication()
    {
        Task.Run(async () =>
        {
            ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[75]);
            while (IsConnected)
            {
                try
                {
                    // This is where I suspect the memory leak is originating - this call I suspect is not properly cleaned up when the object is diposed
                    var result = await SocketTaskExtensions.ReceiveAsync(ClientConnection.Client, buffer, SocketFlags.None).WithCancellation(cts.Token);

                    if (result > 0)
                    {
                        var message = new ClientMessage(buffer.Array, true);
                        if(message.IsValid)
                            HandleClientMessage(message);
                    }
                }
                catch (OperationCanceledException)
                {
                    _closeConnection = true;
                    DisconnectReason = "Client has not reported in 4 mins";
                }
                catch (Exception e)
                {
                    _closeConnection = true;
                    DisconnectReason = "Error during receive opperation";
                }
            }
        });
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            _closeConnection = true;
            cts.Cancel();
            // Explicitly kill the underlying socket
            if (UnitConnection.Client != null)
            {
                UnitConnection.Client.Close();
            }

            UnitConnection.Close();
            cts.Dispose();
        }
    }

任务扩展方法：

public static async Task<T> WithCancellation<T>(this Task<T> task, CancellationToken cancellationToken)
    {
        var tcs = new TaskCompletionSource<bool>();
        using (cancellationToken.Register(s => ((TaskCompletionSource<bool>)s).TrySetResult(true), tcs))
        {
            if (task != await Task.WhenAny(task, tcs.Task))
            {
                throw new OperationCanceledException(cancellationToken);
            }
        }

        return task.Result;
    }

Mananger代码：

    public bool StartListener()
    {
        _listener = new TcpListenerEx(IPAddress.Any, Convert.ToInt32(_serverPort));
        _listener.Start();
        Task.Run(async () =>
        {
            while (_maintainConnection) // <--- boolean flag to exit loop
            {
                try
                {
                    HandleClientConnection(await _listener.AcceptTcpClientAsync());
                }
                catch (Exception e)
                {
                    //<snip>
                }
            }
        });
        return true;
    }

    private void HandleClientConnection(TcpClient client)
    {
        Task.Run(async () =>
        {
            try
            {
                // Create new Coms object
                var client = new ClientComsAsync();
                client.ClientConnection = client;
                // Start client communication
                client.StartCommunication();

                //_clients is the ConcurrentDictionary

                ClientComsAsync existingClient;
                if (_clients.TryGetValue(client.ClientName, out existingClient) && existingClient != null)
                {
                    if (existingClient.IsConnected)
                        existingClient.SendHeatbeat();
                    if (!existingClient.IsConnected)
                    {
                        // Call Dispose on existing client
                        CleanUpClient(existingClient, "Reconnected with new connection");
                    }
                }
            }
            catch (Exception e)
            {
                //<snip>
            }
            finally
            {
                //<snip>
            }
        });
    }

    private void CleanUpClient(ClientComsAsync client, string reason)
    {
        ClientComsAsync _client;
        _units.TryRemove(client.ClientName, out _client);
        if (_client != null)
        {
            _client.Dispose();
        }
    }

Answer 1

当它们闲置5分钟以上时，应用程序的CPU使用率将跃升至90％以上并保持不变。

为解决此问题，我内置了一个4分钟后触发的取消令牌。

正确的解决方法是解决CPU使用率高的问题。

在我看来就像在这里：

while (IsConnected)
{
  try
  {
    var result = await SocketTaskExtensions.ReceiveAsync(ClientConnection.Client, buffer, SocketFlags.None);

    if (result > 0)
    {
      ...
    }
  }
  catch ...
  {
    ...
  }
}

套接字很奇怪，处理原始的TCP / IP套接字非常困难。附带说明一下，我总是鼓励开发人员使用更标准的东西，例如HTTP或WebSockets，但是在这种情况下，您不控制客户端，因此这不是一个选择。

具体来说，您的代码未处理result == 0的情况。如果客户端设备正常关闭了套接字，您将看到result的{{1}}，立即环回并不断获得0的{{1}}-使用CPU。

当然，这是假设result仍然是0。这可能是可能的...

您没有显示在代码中设置IsConnected的位置，但是我怀疑它是在发送心跳消息后在错误处理中。所以这就是为什么它可能无法按预期工作的原因...我怀疑客户端设备正在关闭其发送流（您的接收流），同时保持其接收流（您的发送流）处于打开状态。这是关闭套接字的一种方法，有时被认为是“更礼貌”，因为它允许另一端继续发送数据，即使该端已完成发送。（这是从客户端设备的角度来看的，因此“另一面”是您的代码，而“这一面”是客户端设备）。

这是完全合法的套接字方式，因为每个连接的套接字都是两个流，而不是一个，每个流都可以独立关闭。如果发生这种情况，您的心跳仍将无误地发送和接收（可能只是被客户端设备静默丢弃），true将保持IsConnected，并且读取循环将变得同步并吞噬您的CPU。

要解决此问题，请在您的读取循环中添加对IsConnected的检查，并像心跳发送失败一样清除客户端。

5分钟后TCP套接字高CPU /内存使用率

1 个答案: