Hej där! Som leverantör av uttag har jag själv sett vikten av att använda icke-blockerande uttag i olika applikationer. I den här bloggen kommer jag att gå igenom hur du använder icke-blockerande uttag, och även ge dig lite information om de fantastiska uttagen vi erbjuder.
Vad är icke-blockerande uttag?
Innan vi dyker in i hur man använder icke-blockerande uttag, låt oss snabbt förstå vad de är. Traditionella uttag blockerar, vilket betyder att när du anropar en funktion somrecv()ellerskicka(), kommer ditt program att stanna och vänta tills operationen är klar. Detta kan vara en verklig smärta, särskilt i applikationer där du behöver hantera flera anslutningar eller utföra andra uppgifter samtidigt.
Icke-blockerande sockets, å andra sidan, blockerar inte exekveringen av ditt program. När du anropar en funktion på ett icke-blockerande uttag kommer den tillbaka omedelbart, även om operationen inte är klar. Detta gör att ditt program kan fortsätta att göra andra saker medan du väntar på att socketoperationen ska slutföras.
Installation av icke-blockerande uttag
Det första steget i att använda icke-blockerande sockets är att skapa en socket och ställa in den i icke-blockerande läge. I Python kan du göra så här:
import socket # Skapa ett socketobjekt sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Ställ in socket på icke-blockerande läge sock.setblocking(0)I C är processen lite mer involverad, men fortfarande okomplicerad:
#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; // Skapa en socket sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("skapandet av socket misslyckades"); returnera -1; } // Ställ in socket till icke-blockerande läge int flags = fcntl(sockfd, F_GETFL, 0); fcntl(sockfd, F_SETFL, flaggor | O_NONBLOCK); // Resten av din kod... return 0; }Hantering av icke-blockerande operationer
När du har ställt in ditt uttag till icke-blockerande läge, måste du hantera operationerna noggrant. När du ringerrecv()ellerskicka()på ett icke-blockerande uttag kan det returnera ett fel om operationen inte kan slutföras omedelbart. I de flesta fall kommer detta fel att varaEWOULDBLOCKellerIGEN.
I Python kan du hantera detta så här:
try: data = sock.recv(1024) if data: print(f"Mottaget: {data}") utom socket.error som e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): # Ingen data tillgänglig ännu, fortsätt med andra uppgifter passera else: # Hantera andra fel skriv ut {(ef}")I C är det liknande:
#include <errno.h> //... char buffer[1024]; ssize_t n = recv(sockfd, buffert, sizeof(buffert), 0); if (n < 0) { if (errno == EWOULDBLOCK || errno == EAGAIN) { // Inga data tillgängliga ännu, fortsätt med andra uppgifter } else { // Hantera andra fel perror("recv"); } } annat om (n > 0) { buffert[n] = '\0'; printf("Mottaget: %s\n", buffert); }Använda icke-blockerande uttag för flera anslutningar
En av de största fördelarna med icke-blockerande uttag är att de låter dig hantera flera anslutningar samtidigt. Du kan använda en teknik som kallas polling för att kontrollera om det finns någon aktivitet på flera uttag.
I Python kan du användaväljamodul:
import välj # Lista över uttag för att övervaka ingångar = [sock1, sock2] medan True: läsbar, skrivbar, exceptionell = select.select(ingångar, [], ingångar) för s i läsbar: try: data = s.recv(1024) if data: print(f"Mottaget från {s}: {sock}") exrorer. (socket.EWOULDBLOCK, socket.EAGAIN): pass else: print(f"Fel: {e}") inputs.remove(s) s.close() för s i exceptionella: inputs.remove(s) s.close()I C kan du användavälja()fungera:
#include <sys/select.h> //... fd_set readfds; int max_fd; // Initiera filbeskrivningsuppsättningen FD_ZERO(&readfds); FD_SET(sockfd1, &readfds); FD_SET(sockfd2, &readfds); max_fd = (sockfd1 > sockfd2)? sockfd1: sockfd2; medan (1) { fd_set tmpfds = readfds; int aktivitet = välj(max_fd + 1, &tmpfds, NULL, NULL, NULL); if (aktivitet < 0) { perror("välj"); bryta; } för (int i = 0; i <= max_fd; i++) { if (FD_ISSET(i, &tmpfds)) { char buffer[1024]; ssize_t n = recv(i, buffert, sizeof(buffert), 0); if (n < 0) { if (errno == EWOULDBLOCK || errno == EAGAIN) { fortsätt; } annat { perror("recv"); FD_CLR(i, &readfds); nära(i); } } annat om (n > 0) { buffert[n] = '\0'; printf("Mottaget från %d: %s\n", i, buffert); } } } }Våra uttagserbjudanden
Som uttagsleverantör har vi ett brett utbud av uttag för att möta dina behov. Kolla in vårSlaguttag, som är designade för att klara applikationer med högt vridmoment. Det har vi ocksåVarmsmidda handuttag, som är gjorda med en varmsmideprocess för överlägsen styrka och hållbarhet. Och naturligtvis vårHanduttagär perfekta för allmänt bruk.
Slutsats
Icke-blockerande sockets är ett kraftfullt verktyg som avsevärt kan förbättra prestandan för dina nätverksapplikationer. Genom att låta ditt program fortsätta att köras medan du väntar på att socketoperationer ska slutföras, kan du hantera flera anslutningar mer effektivt och utföra andra uppgifter samtidigt.
Om du är intresserad av att köpa högkvalitativa uttag för dina projekt, tveka inte att höra av dig för en upphandlingsdiskussion. Vi är här för att hjälpa dig hitta rätt uttag för dina behov.
Referenser
- "UNIX Network Programming, Volume 1: The Sockets Networking API" av W. Richard Stevens
- Python officiell dokumentation om
uttagochväljamoduler - C standardbiblioteksdokumentation om sockets programmeringsfunktioner
