Hallo! Als Anbieter von Steckdosen habe ich aus erster Hand gesehen, wie wichtig es ist, in verschiedenen Anwendungen nicht blockierende Steckdosen zu verwenden. In diesem Blog werde ich Ihnen erklären, wie Sie nicht blockierende Steckdosen verwenden, und Ihnen auch ein paar Informationen über die tollen Steckdosen geben, die wir anbieten.
Was sind nicht blockierende Steckdosen?
Bevor wir uns mit der Verwendung nicht blockierender Sockets befassen, wollen wir kurz verstehen, was sie sind. Herkömmliche Sockets blockieren, was bedeutet, dass beim Aufrufen einer Funktion wierecv()oderschicken(), wird Ihr Programm angehalten und warten, bis der Vorgang abgeschlossen ist. Dies kann ein echtes Problem sein, insbesondere bei Anwendungen, bei denen Sie mehrere Verbindungen verwalten oder andere Aufgaben gleichzeitig ausführen müssen.
Nicht blockierende Sockets hingegen blockieren nicht die Ausführung Ihres Programms. Wenn Sie eine Funktion an einem nicht blockierenden Socket aufrufen, kehrt sie sofort zurück, auch wenn der Vorgang noch nicht abgeschlossen ist. Dadurch kann Ihr Programm weiterhin andere Dinge tun, während es auf den Abschluss des Socket-Vorgangs wartet.
Einrichten nicht blockierender Sockets
Der erste Schritt bei der Verwendung nicht blockierender Sockets besteht darin, einen Socket zu erstellen und ihn in den nicht blockierenden Modus zu versetzen. In Python können Sie dies folgendermaßen tun:
import socket # Ein Socket-Objekt erstellen sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Den Socket auf den nicht blockierenden Modus setzen sock.setblocking(0)In C ist der Prozess etwas komplizierter, aber immer noch unkompliziert:
#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; // Einen Socket erstellen sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("Socket-Erstellung fehlgeschlagen"); return -1; } // Setze den Socket auf den nicht blockierenden Modus int flags = fcntl(sockfd, F_GETFL, 0); fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); // Rest Ihres Codes... return 0; }Abwicklung nicht blockierender Vorgänge
Sobald Sie Ihren Socket in den nicht blockierenden Modus versetzt haben, müssen Sie die Vorgänge sorgfältig durchführen. Wenn Sie anrufenrecv()oderschicken()Bei einem nicht blockierenden Socket wird möglicherweise ein Fehler zurückgegeben, wenn der Vorgang nicht sofort abgeschlossen werden kann. In den meisten Fällen wird dieser Fehler auftretenEWOULDBLOCKoderWIEDER.
In Python können Sie dies folgendermaßen handhaben:
try: data = sock.recv(1024) if data: print(f"Received: {data}") außer socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): # Noch keine Daten verfügbar, mit anderen Aufgaben fortfahren pass else: # Andere Fehler behandeln print(f"Error: {e}")In C ist es ähnlich:
#include <errno.h> //... char buffer[1024]; ssize_t n = recv(sockfd, buffer, sizeof(buffer), 0); if (n < 0) { if (errno == EWOULDBLOCK || errno == EAGAIN) { // Noch keine Daten verfügbar, mit anderen Aufgaben fortfahren } else { // Andere Fehler behandeln perror("recv"); } } else if (n > 0) { buffer[n] = '\0'; printf("Received: %s\n", buffer); }Verwendung nicht blockierender Sockets für mehrere Verbindungen
Einer der Hauptvorteile nicht blockierender Sockets besteht darin, dass Sie damit mehrere Verbindungen gleichzeitig verarbeiten können. Sie können eine Technik namens Polling verwenden, um zu überprüfen, ob auf mehreren Sockets Aktivität stattfindet.
In Python können Sie das verwendenwählenModul:
import select # Liste der zu überwachenden Sockets inputs = [sock1, sock2] while True: lesbar, beschreibbar, außergewöhnlich = select.select(inputs, [], inputs) für s in readable: try: data = s.recv(1024) if data: print(f"Received from {s}: {data}") außer socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): übergeben Sie else: print(f"Error: {e}") inputs.remove(s) s.close() für s in Ausnahmefällen: inputs.remove(s) s.close()In C können Sie das verwendenwählen()Funktion:
#include <sys/select.h> //... fd_set readfds; int max_fd; // Initialisiere den Dateideskriptorsatz FD_ZERO(&readfds); FD_SET(sockfd1, &readfds); FD_SET(sockfd2, &readfds); max_fd = (sockfd1 > sockfd2)? sockfd1 : sockfd2; while (1) { fd_set tmpfds = readfds; intactivity = select(max_fd + 1, &tmpfds, NULL, NULL, NULL); if (activity < 0) { perror("select"); brechen; } 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) { continue; } else { perror("recv"); FD_CLR(i, &readfds); close(i); } } else if (n > 0) { buffer[n] = '\0'; printf("Empfangen von %d: %s\n", i, buffer); } } } }Unser Angebot an Steckdosen
Als Steckdosenlieferant verfügen wir über eine große Auswahl an Steckdosen, die Ihren Anforderungen gerecht werden. Schauen Sie sich unsere anSchlagstecknüsse, die für Anwendungen mit hohem Drehmoment ausgelegt sind. Wir haben auchWarmgeschmiedete Handstecknüsse, die im Warmschmiedeverfahren für überragende Festigkeit und Haltbarkeit hergestellt werden. Und natürlich unsereHandsteckdoseneignen sich perfekt für den allgemeinen Einsatz.
Abschluss
Nicht blockierende Sockets sind ein leistungsstarkes Tool, das die Leistung Ihrer Netzwerkanwendungen erheblich verbessern kann. Indem Sie zulassen, dass Ihr Programm weiter ausgeführt wird, während es auf den Abschluss von Socket-Vorgängen wartet, können Sie mehrere Verbindungen effizienter verarbeiten und andere Aufgaben gleichzeitig ausführen.
Wenn Sie daran interessiert sind, hochwertige Steckdosen für Ihre Projekte zu kaufen, zögern Sie nicht, ein Beschaffungsgespräch zu führen. Wir sind hier, um Ihnen zu helfen, die richtigen Steckdosen für Ihre Bedürfnisse zu finden.
Referenzen
- „UNIX Network Programming, Band 1: The Sockets Networking API“ von W. Richard Stevens
- Offizielle Python-Dokumentation zum
BuchseUndwählenModule - Dokumentation der C-Standardbibliothek zu Socket-Programmierfunktionen
