Question

我在c＃中编写了TcpListener的代码，该代码应该从客户端套接字接收请求并处理请求（将处理后的请求发送到我们的另一个Web服务以获得最终响应）然后解析响应并将响应发送回客户端发起请求的套接字。

下面的代码段。

代码在一次接收少量请求时工作正常但现在为了将其移动到云并接受多个请求。我们通过在同一个地方运行JMeter测试来测试此功能。

当我们达到每秒100个线程（端到端测试 - 客户端系统到服务器套接字到我们的Web服务并返回）时，我们得到的吞吐量就像是4，这应该至少为30以匹配客户端要求。如果我们省略了端到端流程，只是从服务器套接字本身发回硬编码响应，我们就会看到吞吐量为700.

找到根本原因我在发送硬核响应时增加了延迟（我们需要与我们的Web服务通信），我可以看到相同的行为，即吞吐量大幅下降= 4 / 3.8

这意味着当TcpListener忙于处理现有请求时，它可能无法参加下一个请求（假设我可能是错的 - 如果是这样，请更正）

请查看代码并帮助我提高性能。

public void StartTCPServer()
    {
        Logger.Write_Info_Log("In StartTCPServer - inPort : " + AESDK_CONFIG.PORT_NO, 1, log);
        try
        {
            // Data buffer for incoming data.
            byte[] bytes = new Byte[1024];

            // Establish the local endpoint for the socket.
            IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, AESDK_CONFIG.PORT_NO);

            // Create a TCP/IP socket.
            Socket listener = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream, ProtocolType.Tcp);

            // Bind the socket to the local endpoint and listen for incoming connections.

            listener.Bind(localEndPoint);
            listener.Listen(100);

            while (true)
            {
                // Set the event to nonsignaled state.
                allDone.Reset();

                // Start an asynchronous socket to listen for connections.
                listener.BeginAccept(
                    new AsyncCallback(AcceptCallback),
                    listener);

                // Wait until a connection is made before continuing.
                allDone.WaitOne();
            }
        }
        catch (Exception Ex)
        {
            Logger.Write_Fatal_Log("Exception in Start Listening : " + Ex.Message, 1, log);
        }
    }

    public void AcceptCallback(IAsyncResult ar)
    {
        // Signal the main thread to continue.
        allDone.Set();

        // Get the socket that handles the client request.
        Socket listener = (Socket)ar.AsyncState;
        Socket handler = listener.EndAccept(ar);

        // Create the state object.
        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
            new AsyncCallback(ReadCallback), state);
    }

    public void ReadCallback(IAsyncResult ar)
    {
        String strdata = String.Empty;

        // Retrieve the state object and the handler socket
        // from the asynchronous state object.
        StateObject state = (StateObject)ar.AsyncState;
        Socket handler = state.workSocket;

        // Read data from the client socket. 
        int bytesRead = handler.EndReceive(ar);

        if (bytesRead > 0)
        {
            // There  might be more data, so store the data received so far.
            state.sb.Append(Encoding.ASCII.GetString(
                state.buffer, 0, bytesRead));

            // Check for end-of-file tag. If it is not there, read 
            // more data.
            strdata = state.sb.ToString();
            if (!string.IsNullOrEmpty(strdata))
            {
                // All the data has been read from the client. 
                if (strdata.Contains("<<CheckConnection>>"))
                {
                    log.Info(GlobalVar.gThreadNo(GlobalVar.gintCurrentThread) + "Data Received: " + strdata);
                    byte[] byData1 = System.Text.Encoding.UTF8.GetBytes("<<CheckConnectionAlive>>");
                    Send(handler, "<<CheckConnectionAlive>>");
                }
                else
                {
                    Interlocked.Increment(ref m_clientCount);
                    //Process incoming requests here and send response back to client
                    string strResponse = GetRequest(strdata, m_clientCount);
                    Send(handler, strResponse);
                }
            }
            else
            {
                // Not all data received. Get more.
                handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReadCallback), state);
            }
        }
    }

    private static void Send(Socket handler, String data)
    {
        // Convert the string data to byte data using ASCII encoding.
        byte[] byteData = Encoding.ASCII.GetBytes(data);

        // Begin sending the data to the remote device.
        handler.BeginSend(byteData, 0, byteData.Length, 0,
            new AsyncCallback(SendCallback), handler);
    }

    private static void SendCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket handler = (Socket)ar.AsyncState;

            // Complete sending the data to the remote device.
            int bytesSent = handler.EndSend(ar);
            Console.WriteLine("Sent {0} bytes to client.", bytesSent);

            handler.Shutdown(SocketShutdown.Both);
            handler.Close();

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

TCP侦听器，每秒应接受100个线程

0 个答案: