Salut! En tant que fournisseur de sockets, j'ai pu constater par moi-même l'importance d'utiliser des sockets non bloquants dans diverses applications. Dans ce blog, je vais vous expliquer comment utiliser les sockets non bloquants, et également vous donner quelques informations sur les superbes sockets que nous proposons.
Que sont les prises non bloquantes ?
Avant de découvrir comment utiliser les sockets non bloquants, comprenons rapidement ce qu'ils sont. Les sockets traditionnelles bloquent, ce qui signifie que lorsque vous appelez une fonction commerecv()ouenvoyer(), votre programme s'arrêtera et attendra que l'opération soit terminée. Cela peut être très pénible, en particulier dans les applications où vous devez gérer plusieurs connexions ou effectuer d'autres tâches simultanément.
Les sockets non bloquants, en revanche, ne bloquent pas l'exécution de votre programme. Lorsque vous appelez une fonction sur un socket non bloquant, elle reviendra immédiatement, même si l'opération n'est pas terminée. Cela permet à votre programme de continuer à faire d'autres choses en attendant la fin de l'opération de socket.
Configuration de sockets non bloquants
La première étape de l'utilisation de sockets non bloquants consiste à créer un socket et à le définir en mode non bloquant. En Python, vous pouvez procéder ainsi :
import socket # Créer un objet socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Mettre le socket en mode non bloquant sock.setblocking(0)En C, le processus est un peu plus complexe, mais reste simple :
#include <stdio.h> #include <stdlib.h> #include <sys/socket.h> #include <fcntl.h> #include <unistd.h> #include <arpa/inet.h> int main() { int sockfd; struct sockaddr_in server_addr ; // Crée une socket sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("échec de la création du socket"); renvoie -1 ; } // Définit le socket en mode non bloquant int flags = fcntl(sockfd, F_GETFL, 0); fcntl(sockfd, F_SETFL, drapeaux | O_NONBLOCK); // Reste de votre code... return 0; }Gestion des opérations non bloquantes
Une fois que vous avez réglé votre socket en mode non bloquant, vous devez gérer les opérations avec soin. Quand tu appellesrecv()ouenvoyer()sur un socket non bloquant, il peut renvoyer une erreur si l'opération ne peut pas être terminée immédiatement. Dans la plupart des cas, cette erreur seraEWOULDBLOCKouÉGAIN.
En Python, vous pouvez gérer cela comme ceci :
try: data = sock.recv(1024) if data: print(f"Received: {data}") except socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): # Aucune donnée disponible pour le moment, continuez avec d'autres tâches, passez else: # Gérez les autres erreurs print(f"Error: {e}")En C, c'est similaire :
#include <errno.h> //... char buffer[1024]; ssize_t n = recv(sockfd, buffer, sizeof(buffer), 0); if (n < 0) { if (errno == EWOULDBLOCK || errno == EAGAIN) { // Aucune donnée disponible pour l'instant, continuez avec d'autres tâches } else { // Gère d'autres erreurs perror("recv"); } } else if (n > 0) { buffer[n] = '\0'; printf("Reçu : %s\n", tampon); }Utilisation de sockets non bloquants pour plusieurs connexions
L'un des principaux avantages des sockets non bloquants est qu'ils vous permettent de gérer plusieurs connexions simultanément. Vous pouvez utiliser une technique appelée sondage pour vérifier s'il y a une activité sur plusieurs sockets.
En Python, vous pouvez utiliser lesélectionnermodule:
import select # Liste des sockets pour surveiller les entrées = [sock1, sock2] while True : lisible, inscriptible, exceptionnel = select.select(inputs, [], inputs) for s in readable: try: data = s.recv(1024) if data: print(f"Reçu de {s}: {data}") sauf socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN) : passez else : print(f"Error : {e}") inputs.remove(s) s.close() pour s en exceptionnel : inputs.remove(s) s.close()En C, vous pouvez utiliser lesélectionner()fonction:
#include <sys/select.h> //... fd_set readfds; int max_fd; // Initialise l'ensemble de descripteurs de fichier FD_ZERO(&readfds); FD_SET(sockfd1, &readfds); FD_SET(sockfd2, &readfds); max_fd = (sockfd1 > sockfd2) ? chaussettefd1 : chaussettefd2; tandis que (1) { fd_set tmpfds = readfds ; int activité = select(max_fd + 1, &tmpfds, NULL, NULL, NULL); if (activité < 0) { perror("select"); casser; } for (int i = 0; i <= max_fd; i++) { if (FD_ISSET(i, &tmpfds)) { char buffer[1024]; ssize_t n = recv(i, buffer, sizeof(buffer), 0); if (n < 0) { if (errno == EWOULDBLOCK || errno == EAGAIN) { continuer ; } else { perror("recv"); FD_CLR(i, &readfds); fermer(je); } } else if (n > 0) { buffer[n] = '\0'; printf("Reçu de %d : %s\n", i, buffer); } } } }Nos offres de douilles
En tant que fournisseur de prises, nous disposons d’une large gamme de prises pour répondre à vos besoins. Consultez notreDouilles à chocs, qui sont conçus pour résister aux applications à couple élevé. Nous avons égalementDouilles à main forgées à chaud, qui sont fabriqués à l'aide d'un processus de forgeage à chaud pour une résistance et une durabilité supérieures. Et bien sûr, notreDouilles à mainsont parfaits pour un usage général.
Conclusion
Les sockets non bloquants sont un outil puissant qui peut considérablement améliorer les performances de vos applications réseau. En permettant à votre programme de continuer à s'exécuter en attendant la fin des opérations sur les sockets, vous pouvez gérer plusieurs connexions plus efficacement et effectuer d'autres tâches simultanément.
Si vous souhaitez acheter des prises de haute qualité pour vos projets, n'hésitez pas à nous contacter pour une discussion sur l'approvisionnement. Nous sommes là pour vous aider à trouver les prises adaptées à vos besoins.
Références
- "Programmation réseau UNIX, Volume 1 : L'API de mise en réseau Sockets" par W. Richard Stevens
- Documentation officielle Python sur le
douilleetsélectionnermodules - Documentation de la bibliothèque standard C sur les fonctions de programmation de socket
