TcpListener ставит соединения в очередь быстрее, чем я могу очистить их

Насколько я понимаю, TcpListener поставит соединения в очередь, после того как Вы звоните Start(). Каждый раз Вы звоните AcceptTcpClient (или BeginAcceptTcpClient), это исключит один объект из очереди от очереди.

Если мы загружаем тест наш TcpListener приложение путем отправки 1 000 соединений с ним сразу, очередь создает намного быстрее, чем мы можем очистить его, ведя (в конечном счете) к тайм-аутам от клиента, потому что это не получило ответ, потому что его соединение было все еще в очереди. Однако сервер, кажется, не испытывает много давления, наше приложение не использует много процессорного времени, и другие контролируемые ресурсы на машине не потеют. Такое чувство, что мы не работаем достаточно эффективно прямо сейчас.

Мы звоним BeginAcceptTcpListener и затем сразу передача к a ThreadPool распараллельте, чтобы на самом деле сделать работу, затем звоня BeginAcceptTcpClient снова. Включенная работа, кажется, не оказывает давления на машину, это - в основном просто 3-секундный сон, сопровождаемый поиском по словарю и затем 100 побайтовыми записями к TcpClientпоток.

Вот TcpListener код мы используем:

    // Thread signal.
    private static ManualResetEvent tcpClientConnected = new ManualResetEvent(false);

    public void DoBeginAcceptTcpClient(TcpListener listener)
    {
        // Set the event to nonsignaled state.
        tcpClientConnected.Reset();

        listener.BeginAcceptTcpClient(
            new AsyncCallback(DoAcceptTcpClientCallback),
            listener);

        // Wait for signal
        tcpClientConnected.WaitOne();
    }

    public void DoAcceptTcpClientCallback(IAsyncResult ar)
    {
        // Get the listener that handles the client request, and the TcpClient
        TcpListener listener = (TcpListener)ar.AsyncState;
        TcpClient client = listener.EndAcceptTcpClient(ar);

        if (inProduction)
            ThreadPool.QueueUserWorkItem(state => HandleTcpRequest(client, serverCertificate));  // With SSL
        else
            ThreadPool.QueueUserWorkItem(state => HandleTcpRequest(client));  // Without SSL

        // Signal the calling thread to continue.
        tcpClientConnected.Set();
    }

    public void Start()
    {
        currentHandledRequests = 0;
        tcpListener = new TcpListener(IPAddress.Any, 10000);
        try
        {
            tcpListener.Start();

            while (true)
                DoBeginAcceptTcpClient(tcpListener);
        }
        catch (SocketException)
        {
            // The TcpListener is shutting down, exit gracefully
            CheckBuffer();
            return;
        }
    }

Я предполагаю, что ответ будет связан с использованием Sockets вместо TcpListener, или по крайней мере использование TcpListener.AcceptSocket, но я задался вопросом, как мы пойдем о выполнении этого?

Одна идея, которую мы имели, состояла в том, чтобы звонить AcceptTcpClient и сразу Enqueue TcpClient в одного из нескольких Queue<TcpClient> объекты. Тем путем мы могли опросить те очереди на отдельных потоках (одна очередь на поток), не сталкиваясь с мониторами, которые могли бы заблокировать поток при ожидании другого Dequeue операции. Каждый поток очереди мог затем использовать ThreadPool.QueueUserWorkItem сделать работу в a ThreadPool распараллельте и затем перейдите на исключение из очереди следующего TcpClient в его очереди. Вы рекомендовали бы этот подход или являетесь нашей проблемой, которую мы используем TcpListener и никакой объем быстрого исключения из очереди не собирается зафиксировать это?