Ehilà! Come fornitore di socket, ho constatato in prima persona l'importanza di utilizzare socket non bloccanti in varie applicazioni. In questo blog ti spiegherò come utilizzare i socket non bloccanti e ti darò anche alcune informazioni sui fantastici socket che offriamo.
Cosa sono i socket non bloccanti?
Prima di approfondire come utilizzare i socket non bloccanti, capiamo rapidamente cosa sono. I socket tradizionali sono bloccanti, il che significa che quando chiami una funzione likerecv()OInviare(), il programma si fermerà e attenderà fino al completamento dell'operazione. Questo può essere un vero problema, soprattutto nelle applicazioni in cui è necessario gestire più connessioni o eseguire altre attività contemporaneamente.
I socket non bloccanti, d'altra parte, non bloccano l'esecuzione del programma. Quando chiami una funzione su un socket non bloccante, verrà restituita immediatamente, anche se l'operazione non è terminata. Ciò consente al programma di continuare a fare altre cose mentre attende il completamento dell'operazione socket.
Configurazione di socket non bloccanti
Il primo passo nell'utilizzo dei socket non bloccanti è creare un socket e impostarlo in modalità non bloccante. In Python, puoi farlo in questo modo:
import socket # Crea un oggetto socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Imposta il socket in modalità non bloccante sock.setblocking(0)In C, il processo è un po' più complicato, ma comunque semplice:
#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; // Crea un socket sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("creazione del socket non riuscita"); ritorno -1; } // Imposta il socket sulla modalità non bloccante int flags = fcntl(sockfd, F_GETFL, 0); fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); // Resto del codice... return 0; }Gestione delle operazioni non bloccanti
Una volta impostato il socket in modalità non bloccante, è necessario gestire le operazioni con attenzione. Quando chiamirecv()OInviare()su un socket non bloccante, potrebbe restituire un errore se l'operazione non può essere completata immediatamente. Nella maggior parte dei casi, questo errore saràEWOULDBLOCKOANCORA.
In Python, puoi gestirlo in questo modo:
try: data = sock.recv(1024) if data: print(f"Ricevuto: {data}") tranne socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): # Nessun dato ancora disponibile, continua con altre attività passa else: # Gestisci altri errori print(f"Errore: {e}")In C, è simile:
#include <errno.h> //... char buffer[1024]; ssize_t n = recv(sockfd, buffer, sizeof(buffer), 0); if (n < 0) { if (errno == EWOULDBLOCK || errno == EAGAIN) { // Nessun dato ancora disponibile, continua con altre attività } else { // Gestisci altri errori perror("recv"); } } else if (n > 0) { buffer[n] = '\0'; printf("Ricevuto: %s\n", buffer); }Utilizzo di socket non bloccanti per connessioni multiple
Uno dei principali vantaggi dei socket non bloccanti è che consentono di gestire più connessioni contemporaneamente. È possibile utilizzare una tecnica chiamata polling per verificare se c'è attività su più socket.
In Python, puoi usare ilselezionaremodulo:
import select # Elenco di socket per monitorare gli input = [sock1, sock2] while True: leggibile, scrivibile, eccezionale = select.select(inputs, [], input) for s in readable: try: data = s.recv(1024) if data: print(f"Ricevuto da {s}: {data}") tranne socket.error as e: if e.errno in (socket.EWOULDBLOCK, socket.EAGAIN): passa else: print(f"Errore: {e}") input.remove(s) s.close() for s in eccezionale: input.remove(s) s.close()In C è possibile utilizzare il fileselezionare()funzione:
#include <sys/select.h> //... fd_set readfds; int max_fd; // Inizializza il set di descrittori di file FD_ZERO(&readfds); FD_SET(sockfd1, &readfds); FD_SET(sockfd2, &readfds); max_fd = (calzinofd1 > calzinofd2)? calzinofd1: calzinofd2; while (1) { fd_set tmpfds = readfds; int attività = select(max_fd + 1, &tmpfds, NULL, NULL, NULL); if (attività < 0) { perror("seleziona"); rottura; } 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) { continua; } else { perror("recv"); FD_CLR(i, &readfds); chiudi(i); } } else if (n > 0) { buffer[n] = '\0'; printf("Ricevuto da %d: %s\n", i, buffer); } } } }Le nostre offerte di prese
In qualità di fornitore di prese, disponiamo di un'ampia gamma di prese per soddisfare le vostre esigenze. Dai un'occhiata al nostroPrese a impatto, progettati per resistere ad applicazioni a coppia elevata. Abbiamo anchePrese manuali forgiate a caldo, realizzati utilizzando un processo di forgiatura a caldo per resistenza e durata superiori. E ovviamente, il nostroPrese manualisono perfetti per l'uso generale.
Conclusione
I socket non bloccanti sono uno strumento potente che può migliorare notevolmente le prestazioni delle tue applicazioni di rete. Consentendo al programma di continuare l'esecuzione mentre si attende il completamento delle operazioni socket, è possibile gestire più connessioni in modo più efficiente ed eseguire altre attività contemporaneamente.
Se sei interessato all'acquisto di prese di alta qualità per i tuoi progetti, non esitare a contattarci per una discussione sull'approvvigionamento. Siamo qui per aiutarti a trovare le prese giuste per le tue esigenze.
Riferimenti
- "Programmazione di rete UNIX, volume 1: API di rete Sockets" di W. Richard Stevens
- Documentazione ufficiale di Python su
PRESAEselezionaremoduli - Documentazione della libreria standard C sulle funzioni di programmazione dei socket
