Le Client-Serveur de connexions multiples en C

Je suis en train de réfléchir sur comment un simple serveur implémenté en C avec des sockets peut gérer les clients en même temps. Disons qu'un simple serveur attend la connexion d'un client et ensuite lire un message envoyé par le client. read() est une fonction de blocage de sorte que le serveur se bloque jusqu'à ce qu'un client écrit. Si on suppose que les deux clients sont d'écrire simultanément sur le serveur. Le serveur va se réveiller à l'un d'eux, mais ce qui va arriver à l'autre? le serveur est toujours "à l'écoute", tandis que le traitement de la demande du premier client? Je sais que la fonction de liaison prend un int en tant que deuxième argument qui spécifie le carnet de commandes (5 par défaut). est-ce à dire que seulement 5 les clients peuvent se connecter simultanément à un serveur? Si c'est vrai, comment sont les serveurs qui prennent en charge plusieurs connexions simultanées sont mis en œuvre?

OriginalL'auteur Keeto | 2015-07-16

  1. 2

    Vous devriez threads. Habituellement, les serveurs ont un thread principal qui est à l'écoute de connexion. Si une connexion est établie, le thread principal créé un autre thread et le passe de connexion pour le nouveau thread. De cette façon, les connexions ont répondu tandis que la thread principal est toujours en mesure d'écouter les nouvelles connexions.

    Edit:
    Voici la listen():

    listen(int socket_fd, int backlog)

    Pour une socket d'écoute kernel gère deux file d'attente.

    • Une connexion incomplète file d'attente pour laquelle SYN a été venu, mais three-way handshake (protocole TCP) ne se fait pas complètement. (SYN_RCV état)
      Une connexion complète de la file d'attente
    • Three-way handshake fait. (L'état) backlog historiquement spécifier la somme des deux files d'attente. Mais il n'y a pas de définition officielle de ce carnet de moyens.
    C'est exactement comment je me suis mise en œuvre. Ma question est ce que si plusieurs connexions se produire avant que le thread principal distribue la connexion à un fil.
    ainsi, lorsqu'une connexion est établie. Un nouveau thread est créé, puis la connexion est passée. Si, au cours de ce processus, une nouvelle connexion, il sera mis en file d'attente jusqu'à ce que le processus est gratuit.
    découvrez l'édition que j'ai fait pour la réponse
    Oui, vous pouvez utiliser un thread par connexion. Puis vient le temps où vous avez plus de clients simultanés puis cœurs dans la boîte.
    Vrai

    OriginalL'auteur Ehsan Ab

  2. 4

    La select(2) et poll(2) appels système ont été inventés pour faire face à cette situation exacte (avec non bloquant les sockets).

    Puis il y a un multi-approche processus avec fork(2), et puis, bien sûr, le serveur peut être mis en œuvre avec fils.

    La meilleure solution pour votre cas dépend de vos besoins spécifiques.

    Être poli et laissez un commentaire lorsque vous en bas de vote.

    OriginalL'auteur Nikolai Fetissov

  3. 2

    Je crois, une façon est d'accepter les connexions en boucle. Ensuite accepté de connexion dans un thread séparé. Il est un exemple de comment le faire ici*. La principale approche est illustré ici:

     while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
 {
        puts("Connection accepted");

        pthread_t sniffer_thread;

        //Copy the value of the accepted socket, in order to pass to the thread
        new_sock = malloc(4);
        *new_sock = client_sock;

        //Create new thread  
        if( pthread_create( &sniffer_thread, NULL,  connection_handler, new_sock) < 0)
        {
            perror("could not create thread");
            return 1;
        }

        //Now join the thread , so that we dont terminate before the thread
        //pthread_join( sniffer_thread , NULL);
        puts("Handler assigned");
    }

    *: Le code dans cet exemple, pourrait ne pas être parfait, mais au moins, vous devriez obtenir l'idée. Par exemple, je ne comprends pas pourquoi l'auteur a alloué un octet pour int. Voir aussi cette.

    C'est exactement comment je me suis mise en œuvre. Ma question est ce que si plusieurs connexions se produire avant que le thread principal distribue la connexion à un fil.
    Je ne suis pas sûr de bien vous comprendre. Dans l'exemple, le serveur accepte la connexion, puis se déplace en attente d'une autre connexion, et ainsi de suite. Si de nombreux clients essaient de se connecter, le serveur va probablement mettre en file d'attente.
    Oui ma question est liée à la manifestation de nombreux clients essaient de se connecter en même temps. Jusqu'à combien de connexions peut-il la file d'attente? Nous n'avons aucun contrôle sur la façon dont grand cette file d'attente est?

    OriginalL'auteur giorgim

  4. 1

    à l'aide de cette fonction sur le serveur: 

    int listen(int sockfd, int backlog);

    Le "retard" indique combien de circulation des clients peut être essayer de se connecter en même temps.

    Lorsque cette fonction retourne: 

    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

    puis immédiatement , passez le sockfd paramètre à la 

    int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                      void *(*start_routine) (void *), void *arg);

    avoir le thread pour gérer la communication avec le client.

    Remarque: la création d'un thread est coûteux et lent, donc, un "pool" de threads doit d'abord être créé et activer un pour chaque connexion client et lorsque le client se déconnecte, retour le fil de la piscine

    OriginalL'auteur user3629249