C#和TCP客户端(异步)具有非常高的CPU负载以及如何检测断开连接的客户端？

Question

如果多个客户端连接,则CPU负载为90+.如果我启动监听器并且没有连接,一切都很棒.如果我有一个或多个连接,我的CPU负载非常高.

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace Test.Socket
{
    public class Server
    {
        List<Thread> WorkListenerThread;

        TcpListener Listener;

        public Server()
        {
            WorkListenerThread = new List<Thread>();
        }

        public void Start()
        {
            try
            {
                Listener = new TcpListener(IPAddress.Any, 12345);
                Listener.Start();
                StartTCPClientListener();
            }
            catch (Exception) { }
        }

        private void StartTCPClientListener()
        {
            Listener.BeginAcceptTcpClient(new AsyncCallback(HandleTCPClientConnection), null);
        }

        private void HandleTCPClientConnection(IAsyncResult ar)
        {
            // Problem 1: after the first connection i have a high cpu load
            try
            {
                TcpClient client = Listener.EndAcceptTcpClient(ar);
                Thread clientThread = new Thread(Communicator.CreateConnection);
                clientThread.Start(client);
                WorkListenerThread.Add(clientThread);

                StartTCPClientListener(); // Next client
            }
            catch (Exception) { }
        }

        public void Stop()
        {
            foreach (Thread th in WorkListenerThread)
                if (th.IsAlive)
                    th.Abort();

            // Problem 2: Exception because the "HandleTCPClientConnection" get a wrong IAsyncResult
            if (Listener != null)
                Listener.Stop();
        }
    }
}

还有我的客户课.

using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using JsonExSerializer;

namespace Test.Socket
{
    class Communicator
    {
        private TcpClient TcpClient = null;
        private NetworkStream Stream = null;

        private Communicator(TcpClient client)
        {
            TcpClient = client;
            Stream = TcpClient.GetStream();
            StartCommunication();
        }

        public static void CreateConnection(object c)
        {
            new Communicator(c as TcpClient);
        }

        private void StartCommunication()
        {
            string message; // The message
            int bytesRead; // Message length
            byte[] buffer = new byte[512]; // buffer

            while (true)
            {
                message = String.Empty;
                do
                {
                    bytesRead = Stream.Read(buffer, 0, buffer.Length);
                    message += Encoding.Default.GetString(buffer, 0, bytesRead);
                } while (!message.EndsWith("\r\n.\r\n"));

                Send("OK", Stream);
            }
        }

        protected void Send(string message, NetworkStream clientStream)
        {
            byte[] temp = Encoding.Default.GetBytes(message);
            clientStream.Write(temp, 0, temp.Length);
            clientStream.Flush();
        }
    }
}

我不知道什么是错的 - .-

任何人都知道如果客户端断开连接我怎么能检测到？那也不错.

但修复高CPU负载将是足够的.

Answer 1

我猜这里的主要问题是:

while (true)
{
    message = String.Empty;
    do
    {
        bytesRead = Stream.Read(buffer, 0, buffer.Length);
        message += Encoding.Default.GetString(buffer, 0, bytesRead);
    } while (!message.EndsWith("\r\n.\r\n"));

    Send("OK", Stream);
}

你应该检查这bytesRead是否是非正面的; 如果是,那是流的末尾,你应该终止:没有更多的数据是以往任何时候都来了,但你是在一个紧凑的循环追加空字符串永远.

然而!更大的问题是方法:每个客户端的线程根本不会扩展,并不是人们提到"异步IO"时的意思.

我还会说,有一个构造函数启动一个长时间运行的操作(所以不返回)是一件可怕的事情.