Comment répartir les connexions entrantes de tcplistener sur des threads dans .NET?

Lors de l'utilisation du Net.Les Sockets.TcpListener, quelle est la meilleure façon de gérer les connexions entrantes (.AcceptSocket) sous la forme de plusieurs threads?

L'idée est de commencer un nouveau thread lorsqu'une nouvelle connexion est acceptée, alors que le tcplistener puis reste disponible pour d'autres connexions entrantes (et pour chaque nouvelle connexion entrante un nouveau thread est créé). Toute la communication et la résiliation avec le client d'origine de la connexion seront traitées dans le fil.

Exemple C# de VB.NET le code est apprécié.

source d'informationauteur Jorrit Reedijk

  1. 14

    Le code que j'ai été en utilisant ressemble à ceci:

    class Server
{
  private AutoResetEvent connectionWaitHandle = new AutoResetEvent(false);

  public void Start()
  {
    TcpListener listener = new TcpListener(IPAddress.Any, 5555);
    listener.Start();

    while(true)
    {
      IAsyncResult result =  listener.BeginAcceptTcpClient(HandleAsyncConnection, listener);
      connectionWaitHandle.WaitOne(); //Wait until a client has begun handling an event
      connectionWaitHandle.Reset(); //Reset wait handle or the loop goes as fast as it can (after first request)
    }
  }


  private void HandleAsyncConnection(IAsyncResult result)
  {
    TcpListener listener = (TcpListener)result.AsyncState;
    TcpClient client = listener.EndAcceptTcpClient(result);
    connectionWaitHandle.Set(); //Inform the main thread this connection is now handled

    //... Use your TcpClient here

    client.Close();
  }
}
  2. 3

    Je crois que vous le faites de la même manière que toute autre opération asynchrone .NET: vous appelez la BeginXxx version de la méthode, dans ce cas BeginAcceptSocket. Votre rappel de l'exécuter sur le pool de threads.

    Pool de threads généralement échelle beaucoup mieux que de thread par connexion: une fois que vous obtenez plus de quelques dizaines de connexions, le système fonctionne un peu plus difficile dans la commutation entre les threads que sur l'obtention de travail réel effectué. En outre, chaque thread possède sa propre pile, qui est généralement de 1 mo en taille (mais cela dépend de lien drapeaux) qui se retrouve dans les 2 go d'espace d'adressage virtuel (sur les systèmes 32 bits); dans la pratique, cela vous limite à moins de 1000 threads.

    Je ne suis pas sûr qu' .NET threadpool utilise actuellement, mais Windows a un noyau de l'objet appelé I/O Port d'Achèvement qui aide à évolutive I/O. Vous pouvez associer des threads avec cet objet, et les demandes d'e/S (y compris accepter des connexions entrantes) peuvent être associés. Lorsque l'e/S est terminée (par exemple, une connexion arrive) Windows va libérer un thread en attente, mais seulement si le nombre de threads exécutables (pas bloquée pour une autre raison) est inférieure à la configuration de l'évolutivité de la limite pour l'achèvement de port. En général, vous définissez une petite multiple du nombre de cœurs.

  3. 2

    Je voudrais suggérer une autre approche:
    Ma suggestion n'utilise que deux fils.
    * un thread vérifie incomming connexions.
    * Lors d'une nouvelle connexion a ouvert cette info est écrit au partage d'une structure de données qui contient toutes les connexions ouvertes en cours.
    * Le 2ème fil d'énumérer les données de structure et pour chaque connexion ouverte, de recevoir les données envoyées et envoyer des réponses.

    Cette solution est plus évolutive thread-sage et si sa mise en œuvre currectly devrait avoir de meilleures performances, alors l'ouverture d'un nouveau thread par connexion ouverte.

  4. 1

    Il y a un bon exemple dans le O'Reilly de C# 3.0, livre de cuisine. Vous pouvez télécharger la source d'accompagnement de http://examples.oreilly.com/9780596516109/CSharp3_0CookbookCodeRTM.zip

  5. 0

    Je voudrais utiliser un pool de threads, de cette façon, vous n'aurez pas à commencer un nouveau thread à chaque fois (car c'est un peu cher). Je voudrais aussi ne pas attendre indefinetely pour plus d'connexions, car les clients ne peuvent pas fermer leurs connexions. Comment envisagez-vous l'itinéraire du client pour le même thread à chaque fois?

    Désolé, de ne pas avoir de l'échantillon.