C Academy · Leçon

Gérer plusieurs clients

select et poll

Gérer plusieurs clients est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Le problème de la concurrence

Un serveur simple traite un client à la fois. Si un client est lent, tous les autres attendent. Pour servir de nombreux clients simultanément, vous avez besoin d'un modèle différent.

Approches de la concurrence

Trois stratégies courantes :

un thread ou un processus par client : simple, mais coûteux à grande échelle
multiplexage des entrées-sorties avec select ou poll : un thread surveille de nombreuses sockets
boucles d'événements avec epoll/kqueue : s'adapte à des milliers de connexions

Rôle de select

select() surveille un ensemble de descripteurs de fichiers et vous indique lesquels sont prêts à être lus ou écrits, ou lesquels comportent des erreurs, le tout au moyen d'un seul appel bloquant. Un thread peut ainsi gérer de nombreuses sockets.

Principes de base de fd_set

select utilise un masque de bits fd_set. Gérez-le avec les macros suivantes : FD_ZERO, FD_SET, FD_CLR et FD_ISSET.

#include <sys/select.h>

void setup_set(fd_set *set, int listen_fd) {
    FD_ZERO(set);          /* clear all */
    FD_SET(listen_fd, set); /* watch the listener */
}

Appeler select

select a besoin du descripteur de fichier le plus élevé augmenté de un et modifie l'ensemble sur place pour marquer les descripteurs prêts. Comme l'opération est destructive, vous devez reconstruire l'ensemble avant chaque appel.

#include <sys/select.h>
#include <stdio.h>

int wait_ready(int maxfd, fd_set *read_set) {
    int n = select(maxfd + 1, read_set, NULL, NULL, NULL);
    if (n < 0) perror("select");
    return n; /* number of ready fds */
}

La boucle du serveur avec select

Le schéma est le suivant : reconstruire l'ensemble, appeler select, puis, pour chaque descripteur prêt, accepter un nouveau client s'il s'agit du descripteur d'écoute, ou lire les données s'il s'agit d'un client.

#include <sys/select.h>

void loop_skeleton(int listen_fd, fd_set *master, int maxfd) {
    fd_set work;
    for (;;) {
        work = *master;           /* copy, select destroys it */
        select(maxfd + 1, &work, NULL, NULL, NULL);
        for (int fd = 0; fd <= maxfd; fd++) {
            if (!FD_ISSET(fd, &work)) continue;
            /* fd == listen_fd -> accept; else -> recv */
        }
    }
}

Suivre les clients

Lorsque vous acceptez une nouvelle connexion, ajoutez son descripteur de fichier à l'ensemble principal et mettez à jour maxfd. Lorsqu'un client se déconnecte (recv renvoie 0), appelez close sur son descripteur et retirez-le de l'ensemble avec FD_CLR.

#include <sys/select.h>
#include <unistd.h>

void add_client(fd_set *master, int *maxfd, int conn) {
    FD_SET(conn, master);
    if (conn > *maxfd) *maxfd = conn;
}
void drop_client(fd_set *master, int conn) {
    close(conn);
    FD_CLR(conn, master);
}

Limites de select

select présente plusieurs inconvénients :

limité à FD_SETUP descripteurs (souvent 1024)
parcours en O(n) de tous les descripteurs à chaque appel
reconstruction de l'ensemble à chaque itération

Pour de nombreuses connexions, poll ou epoll offrent une meilleure montée en charge.

Ce que propose poll

poll() prend un tableau de struct pollfd au lieu d'un masque de bits fixe. Il n'est donc pas limité à 1024 descripteurs et ne détruit pas les données d'entrée à chaque appel.

#include <poll.h>

void setup_poll(struct pollfd *pfd, int listen_fd) {
    pfd[0].fd = listen_fd;
    pfd[0].events = POLLIN; /* notify when readable */
}

Appeler poll

poll se bloque jusqu'à ce qu'au moins un descripteur soit prêt (ou que le délai d'attente expire), puis définit revents pour chaque entrée prête.

#include <poll.h>
#include <stdio.h>

int poll_ready(struct pollfd *pfds, int count) {
    int n = poll(pfds, count, -1); /* -1 = block forever */
    if (n < 0) perror("poll");
    return n;
}

Passer à l'échelle : epoll

Pour des milliers de connexions, epoll sous Linux (et kqueue sous BSD) ne renvoie que les descripteurs prêts, en O(1) par événement, évitant ainsi le parcours complet effectué par select et poll.

Vérification rapide

Testez votre compréhension de la gestion de plusieurs clients.

Récapitulatif

Vous avez appris à servir de nombreux clients avec un seul thread.

select surveille de nombreux descripteurs ; gérez-les avec les macros FD_
Reconstruisez l'ensemble à chaque boucle, car select est destructif
Ajoutez les clients acceptés à l'ensemble ; retirez-les à la déconnexion
poll évite la limite de 1024 ; epoll s'adapte à des milliers de connexions

Questions Fréquemment Posées

La leçon « Gérer plusieurs clients » est-elle gratuite ?

Oui — le texte complet de « Gérer plusieurs clients » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gérer plusieurs clients » ?

select et poll Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Gérer plusieurs clients » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C Academy