Bok tamo! Kao dobavljač utičnica, iz prve sam ruke vidio važnost korištenja neblokirajućih utičnica u raznim aplikacijama. U ovom blogu ću vas provesti kroz kako koristiti neblokirajuće utičnice, a također ću vam dati malo informacija o izvrsnim utičnicama koje nudimo.
Što su utičnice koje ne blokiraju?
Prije nego što zaronimo u to kako koristiti neblokirajuće utičnice, idemo brzo shvatiti što su one. Tradicionalne utičnice blokiraju, što znači da kada pozovete funkciju poputrecv()iliposlati(), vaš program će se zaustaviti i pričekati dok operacija ne završi. To može biti prava muka, osobito u aplikacijama u kojima morate upravljati s višestrukim vezama ili obavljati druge zadatke istovremeno.
Utičnice koje ne blokiraju, s druge strane, ne blokiraju izvođenje vašeg programa. Kada pozovete funkciju na utičnici koja ne blokira, ona će se odmah vratiti, čak i ako operacija nije dovršena. Ovo omogućuje vašem programu da nastavi raditi druge stvari dok čeka da se operacija utičnice završi.
Postavljanje neblokirajućih utičnica
Prvi korak u korištenju neblokirajućih utičnica je stvaranje utičnice i postavljanje u neblokirajući način rada. U Pythonu to možete učiniti ovako:
import socket # Kreirajte socket objekt sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Postavite socket na način rada bez blokiranja sock.setblocking(0)U C-u je proces malo složeniji, ali još uvijek jednostavan:
#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; // Kreiraj utičnicu sockfd = utičnica(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("kreiranje utičnice nije uspjelo"); povratak -1; } // Postavi utičnicu na način rada bez blokiranja int flags = fcntl(sockfd, F_GETFL, 0); fcntl(sockfd, F_SETFL, zastavice | O_NONBLOCK); // Ostatak vašeg koda... return 0; }Rukovanje operacijama koje ne blokiraju
Nakon što postavite svoju utičnicu na način rada bez blokiranja, morate pažljivo rukovati operacijama. Kad nazovešrecv()iliposlati()na utičnici koja ne blokira, može vratiti pogrešku ako se operacija ne može odmah dovršiti. U većini slučajeva, ova će pogreška bitiBLOKIRAO BIiliPONOVNO.
U Pythonu to možete učiniti ovako:
try: data = sock.recv(1024) if data: print(f"Received: {data}") osim socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): # Podaci još nisu dostupni, nastavite s drugim zadacima pass else: # Rukovanje drugim pogreškama print(f"Error: {e}")U C-u je slično:
#include <errno.h> //... char buffer[1024]; ssize_t n = recv(sockfd, buffer, sizeof(buffer), 0); if (n < 0) { if (errno == EWOULDBLOCK || errno == EAGAIN) { // Podaci još nisu dostupni, nastavite s drugim zadacima } else { // Rukovanje drugim pogreškama perror("recv"); } } else if (n > 0) { buffer[n] = '\0'; printf("Primljeno: %s\n", međuspremnik); }Korištenje neblokirajućih utičnica za višestruke veze
Jedna od glavnih prednosti neblokirajućih utičnica je ta što vam omogućuju upravljanje višestrukim vezama istovremeno. Možete upotrijebiti tehniku koja se zove prozivanje da provjerite postoji li aktivnost na višestrukim utičnicama.
U Pythonu možete koristitiodabratimodul:
import select # List of socket to monitor inputs = [sock1, sock2] while True: readable, writable, exceptional = select.select(inputs, [], inputs) for s in readable: try: data = s.recv(1024) if data: print(f"Received from {s}: {data}") osim socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): pass else: ispis(f"Pogreška: {e}") inputs.remove(s) s.close() za s u iznimno: inputs.remove(s) s.close()U C-u možete koristitiodaberite ()funkcija:
#include <sys/select.h> //... fd_set readfds; int max_fd; // Inicijaliziraj skup deskriptora datoteke FD_ZERO(&readfds); FD_SET(sockfd1, &readfds); FD_SET(sockfd2, &readfds); max_fd = (sockfd1 > sockfd2)? sockfd1 : sockfd2; dok (1) { fd_set tmpfds = readfds; int aktivnost = odabir(max_fd + 1, &tmpfds, NULL, NULL, NULL); if (aktivnost < 0) { perror("odaberi"); slomiti; } 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) { nastavi; } else { pogreška("recv"); FD_CLR(i, &readfds); zatvori(i); } } else if (n > 0) { buffer[n] = '\0'; printf("Primljeno od %d: %s\n", i, međuspremnik); } } } }Naša ponuda utičnica
Kao dobavljač utičnica, imamo širok izbor utičnica koje će zadovoljiti vaše potrebe. Provjerite našeUdarne utičnice, koji su dizajnirani da izdrže primjene visokog zakretnog momenta. Također imamoVruće kovane ručne utičnice, koji su izrađeni postupkom vrućeg kovanja za vrhunsku čvrstoću i izdržljivost. I naravno, našRučne utičnicesavršeni su za opću upotrebu.
Zaključak
Neblokirajuće utičnice moćan su alat koji može uvelike poboljšati performanse vaših mrežnih aplikacija. Dopuštajući vašem programu da nastavi s izvođenjem dok čeka na dovršetak operacija utičnice, možete učinkovitije upravljati višestrukim vezama i istovremeno obavljati druge zadatke.
Ako ste zainteresirani za kupnju visokokvalitetnih utičnica za svoje projekte, nemojte se ustručavati posegnuti za razgovorom o nabavi. Ovdje smo da vam pomognemo pronaći prave utičnice za vaše potrebe.
Reference
- "UNIX mrežno programiranje, svezak 1: Sockets Networking API" W. Richarda Stevensa
- Python službena dokumentacija o
utičnicaiodabratimoduli - Dokumentacija C standardne knjižnice o funkcijama programiranja utičnica
