[C] Implementazione Terminazione Gentile con SIGINT e SIGTERM

[Scanca]

Ciao a tutti,

nel mio programma multithread devo implementare un algoritmo di terminazione gentile alla ricezione dei segnali SIGINT e SIGTERM.
Come deve essere implementato il gestore? dove devo mettere le join dei thread?
Io uso una variabile globale per terminare i cicli infiniti dei thread tramite il gestore di segnale e vorrei che il main finisse l'esecuzione ripulendo l'ambiente (chiusura socket, chiusura file temporanei, free,ecc...)
Solo che non capisco come fare di preciso la gestione dei segnali

[WarDuck]

Il segnale può essere gestito o in maniera asincrona, quindi con il gestore del segnale che viene invocato quando viene ricevuto uno, oppure sincrona, aspettando ad esempio nel main un segnale (bloccandoti).

Nel primo caso, ovvero il caso asincrono, devi tenere in considerazione che può arrivare in qualsiasi momento.

Puoi vedere il gestore del segnale come se fosse un altro thread, di durata breve.

Lì puoi ad esempio modificare una variabile globale booleana (flag) e, se non hai bisogno di una segnalazione immediata, aspettare che chi è in loop su quella variabile se ne accorga.

ATTENZIONE: proprio perché il gestore si comporta come un altro thread devi assicurarti che il compilatore non ottimizzi il loop credendo che la variabile assumi sempre il valore "true".

Puoi fare questo dichiarando la variabile come "volatile": in tal caso verrà effettuato sempre l'accesso in memoria e questo ti mette al riparto da eventuali modifiche "sotto al naso".

[Scanca]

Quindi, se non ho capito male devo chiamare le join sia nel main che nel gestore giusto? O in uno di questi due posti?
Io uso già una variabile appuno volatile chiamata run che è a 0 e che metto a 1 nel gestore del SIGINT.
Dopo che ho fatto questo cosa devo fare nel gestore?

[fano]

All'inizio del main scrivi:

void die (int signal)
{
       // segnaliamo in qualche modo ai thread che devono uscire

       for (i = 0; i < n_threads; i++)
            pthread_join();

       exit(signal);
}


int main(void)
{
      signal(SEGFAULT, die);
      signal(SIGPIPE, die);
      signal(SIGxxx, die); 

      [...]
      die(0);
}

I miei programmi di solito non terminano mai con exit(), ma appunto con die() che quindi ha la doppia funzione di uscita fatale e uscita con successo... sempre il clean up debbo fare.

Detto questo in C l'interazione tra thread e segnali è un po' complessa per esempio anche se la logica dice che il sighandler dovrebbe essere eseguita dal main thread questo non è garantito potrebbe eseguirlo un thread a caso o quello che è andato in core!

Una possibilità per fare clean up nei thread che sono i "proprietari" delle risorse è usare il costrutto pthread_cleanup_push() / pthread_cleanup_pop(): http://man7.org/linux/man-pages/man3...up_push.3.html

Insomma auguri !

[WarDuck]

Originariamente inviato da Scanca

Quindi, se non ho capito male devo chiamare le join sia nel main che nel gestore giusto? O in uno di questi due posti?
Io uso già una variabile appuno volatile chiamata run che è a 0 e che metto a 1 nel gestore del SIGINT.
Dopo che ho fatto questo cosa devo fare nel gestore?

Non vedo a cosa serve la JOIN nel signal handler.

Al massimo è il main che si pone in JOIN dei suoi thread figli.

Il gestore del segnale può anche solo impostare un flag e terminare.

PS: signal è deprecato, dovresti usare sigaction.