IO asynchrones avec epoll et kqueue
Gérer un grand nombre de connexions avec epoll sous Linux et kqueue sous BSD ou macOS
IO asynchrones avec epoll et kqueue est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Pourquoi les E/S asynchrones ?
Un fil d'exécution par connexion ne peut pas évoluer jusqu'à des milliers ou des millions de clients. Les E/S asynchrones permettent à un seul fil d'exécution de gérer de nombreux sockets en attendant que l'un d'eux devienne lisible ou accessible en écriture.
Linux : epoll
epoll est l'API d'événements évolutive de Linux. Ajoutez des descripteurs de fichiers à une instance epoll, puis attendez les événements sur chacun d'eux.
#include <sys/epoll.h>
int epfd = epoll_create1(0);
epoll_event ev{};
ev.events = EPOLLIN;
ev.data.fd = sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ev);Attente des événements
epoll_wait bloque jusqu'à ce que des événements soient disponibles, puis renvoie les descripteurs prêts.
epoll_event events[64];
int n = epoll_wait(epfd, events, 64, -1);
for (int i = 0; i < n; ++i) {
int fd = events[i].data.fd;
handle_io(fd);
}Déclenchement par front contre déclenchement par niveau
Deux modes :
- déclenchement par niveau (par défaut) — epoll continue de signaler l'événement tant que la condition est vraie
- déclenchement par front (
EPOLLET) — le signale uniquement lors d'un changement d'état ; vous devez vider complètement le socket à chaque fois
macOS et BSD : kqueue
kqueue est l'équivalent BSD d'epoll, également disponible sous macOS. Le principe est similaire, mais l'API est différente.
#include <sys/event.h>
int kq = kqueue();
struct kevent ev;
EV_SET(&ev, sock, EVFILT_READ, EV_ADD, 0, 0, nullptr);
kevent(kq, &ev, 1, nullptr, 0, nullptr);Windows : IOCP
Windows utilise les ports d'achèvement des E/S (IOCP), un modèle fondé sur l'achèvement (notification une fois l'opération terminée), plutôt que le modèle de disponibilité d'epoll et de kqueue.
Sockets non bloquants
Configurez les sockets en mode non bloquant avec fcntl(fd, F_SETFL, O_NONBLOCK). Sinon, les lectures et les écritures peuvent bloquer toute la boucle d'événements.
Schéma de boucle d'événements
Une boucle qui s'exécute indéfiniment :
- Attendre les événements prêts
- Pour chaque événement, effectuer des E/S jusqu'à ce qu'elles soient sur le point de bloquer
- Recommencer
Gestion de nombreux clients
Un seul fil d'exécution epoll peut gérer des dizaines de milliers de connexions simultanées — c'est le problème C10K. Les systèmes modernes vont jusqu'à plusieurs millions.
Pièges courants
Faites attention aux points suivants :
- Oublier d'activer le mode non bloquant
- Utiliser le déclenchement par front sans vider le socket
- Ne pas supprimer les descripteurs fermés de l'ensemble epoll
- Les fuites de tampons par connexion
Encapsulations de plus haut niveau
Écrire une boucle epoll manuellement est une source d'erreurs. Utilisez libuv, libevent ou Boost.Asio pour le code de production : ces bibliothèques abstraient les différences entre plateformes et fournissent des boucles d'E/S testées.
Asynchrone contre fils d'exécution
Les E/S asynchrones sont plus évolutives, mais plus difficiles à écrire. Pour les serveurs comptant quelques milliers de connexions, le modèle d'un fil d'exécution par connexion est plus simple. Choisissez en fonction de la charge prévue.
Vérification rapide
Quelle est la différence entre les modes de déclenchement par front et par niveau dans epoll ?
Récapitulatif
Les E/S asynchrones permettent une concurrence massive en gérant de nombreux sockets dans un seul fil d'exécution. Linux utilise epoll, BSD et macOS utilisent kqueue, et Windows utilise IOCP. Configurez les sockets en mode non bloquant. En production, utilisez une bibliothèque (Asio, libuv, libevent) plutôt que de coder vous-même la boucle d'événements.
Questions Fréquemment Posées
La leçon « IO asynchrones avec epoll et kqueue » est-elle gratuite ?
Oui — le texte complet de « IO asynchrones avec epoll et kqueue » 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 « IO asynchrones avec epoll et kqueue » ?
Gérer un grand nombre de connexions avec epoll sous Linux et kqueue sous BSD ou macOS 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 3 sur 4.
Combien de temps prend la leçon « IO asynchrones avec epoll et kqueue » ?
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
- API des sockets BSD en C++
- Construire un serveur d’écho TCP
- IO asynchrones avec epoll et kqueue
- Utiliser Boost Asio pour des IO asynchrones modernes