Come lasciare che un thread che blocca su recv() esca con garbo?

Question

C'è un filo piace questo:

{ 
    ......  
    while (1) 
    { 
     recv(socket, buffer, sizeof(buffer), 0); 
     ...... 
    } 
    close(socket);   
} 

perché il thread sta bloccando il recv() chiamata, come posso lasciare che l'uscita filo con grazia?

Answer 1

È possibile chiamare: -

shutdown(sock, SHUT_RDWR) //on the remote end 

check this fuori.

Answer 2

Dichiarare una bandiera uscita globale:

int bExit = 0; 

Facciamo le parti cirtical testarlo:

while(1) 
{ 
    ssize_t result = recv(socket, buffer, sizeof(buffer), 0); 
    if ((-1 == result) && (EINTR == error) && bExit) 
    { 
    break; 
    } 

    ... 
} 

Per rompere il lettore, prima impostare il flag di uscita

bExit = 1; 

quindi inviare un segnale al thread del lettore

pthread_kill(pthreadReader, SIGUSR1); 

---

Nota: Quello che ho lasciato fuori in questo esempio è la protezione della bExit contro l'accesso simultaneo.

Questo potrebbe essere ottenuto utilizzando un mutex o una dichiarazione appropriata.

Answer 3

Non bloccare su recv. Piuttosto implementare un blocco su 'select' e testare l'input fdset per determinare se c'è qualcosa da leggere in primo luogo.

Se sono presenti dati da leggere, chiamare recv. In caso contrario, loop, controlla la variabile booleana volitile 'isrunning' che viene impostata dall'altro thread una volta avviato l'arresto.

Answer 4

Inoltre, impostare la presa da bloccano il sistema:

int listen_sd = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP); 
if (listen_sd < 0) { 
    perror("socket() failed"); 
} 

int on = 1; 

//set socket to be non-blocking 
int rc = ioctl(listen_sd, FIONBIO,(char *)&on); 
if (rc < 0) { 
    perror("ioctl() failed"); 
    close(listen_sd); 
} 

Quindi, è possibile chiamare recv() sul socket, e non bloccherà. Se non c'è niente da leggere poi la variabile globale ERRNO è impostata alla costante EWOULDBLOCK

int rc = recv(listen_sd, buffer, sizeof(buffer), 0); 
if (rc < 0) { 
    if (errno != EWOULDBLOCK) { 
     perror("recv() failed"); 
    } 
} 

Answer 5

Dichiarare un po booleano 'stop', a controllare dopo ogni recv ritorno() e terminare se è impostato. Per spegnere, imposta il bool e chiudi il socket da un altro thread. Il blocco recv() restituirà 'immediatamente' un errore, ma non importa 'perché stai per terminare comunque :)

Answer 6

Probabilmente userò segnali come in @ alk's fine answer (anche discusso here) .

In alternativa, è possibile utilizzare I/O multiplex.

All'inizializzazione, creare una pipe globale (2). Quando è il momento di terminare il programma, chiudi la fine di scrittura del tubo - ora il read-end sceglierà immediatamente (2)/sondaggio (2) leggibile (per EOF). Nel frattempo, i tuoi thread recv-bloccati includono il read-end di questa pipe insieme ai loro socket, per esempio, una chiamata select (2) a blocco indefinito.Se il read-end della pipe ritorna leggibile, i thread I/O sanno che è ora di terminare con grazia.

L'avvertimento principale di questa tecnica è di assicurare che il fine-scrittura venga chiuso una sola volta, in quanto un successivo, ingenuo vicino (2) potrebbe stroncare un file innocente a cui è stato assegnato lo stesso descrittore del vecchio tubo write-end.

Answer 7

O:

1. Impostare un timeout di lettura, con setsockopt() e SO_RCVTIMEO, e ogni volta che si innesca controllare una variabile di stato per vedere se ti sei detto di smettere di leggere.
2. Se si desidera interrompere la lettura del socket per sempre, spegnerlo per l'immissione con shutdown(sd, SHUT_RD). Ciò causerà recv() per restituire zero da ora in poi.
3. Impostare il socket in modalità non bloccante e utilizzare select() con un timeout per indicare quando leggere, adottando la stessa strategia con una variabile di stato come (1) sopra. Tuttavia, la modalità non bloccante introduce notevoli complicazioni nell'operazione di invio, quindi dovresti preferire (1) o (2) sopra.

Il tuo pseudo-codice manca di EOS- e di controllo degli errori. Spero non sia proprio così.