-
Crea un thread separato quando sai che non vorrai aspettarlo con
pthread_join(). L'unico vantaggio in termini di prestazioni è che quando un thread scollegato termina, le sue risorse possono essere rilasciate immediatamente invece di dover attendere l'unione del thread prima che le risorse possano essere rilasciate. -
È "legale" non unire un thread unibile; ma di solito non è consigliabile perché (come notato in precedenza) le risorse non verranno rilasciate fino a quando il thread non viene unito, quindi rimarranno bloccate a tempo indeterminato (fino all'uscita dal programma) se non ti unisci.
Quando dovrei creare un thread come distaccato, fin dall'inizio?
Ogni volta che all'applicazione non importa quando quel thread viene completato e non si preoccupa nemmeno del suo valore di ritorno di un thread (un thread può comunicare un valore a un altro thread/applicazione tramite pthread_exit ).
Ad esempio, in un modello di applicazione client-server, un server può creare un nuovo thread per elaborare ogni richiesta. Ma il server stesso non si preoccupa del valore di ritorno del thread del thread. In tal caso, ha senso creare detached thread.
L'unica cosa che il server deve garantire è che le richieste attualmente elaborate siano completate. Cosa che può fare, semplicemente uscendo dal thread principale senza uscire dall'intero programma/applicazione. Quando l'ultimo thread nel processo termina, l'applicazione/programma si chiuderà naturalmente.
Lo pseudocodice potrebbe essere simile a:
/* A server application */
void process(void *arg)
{
/* Detach self. */
pthread_detach(pthread_self());
/* process a client request. */
pthread_exit(NULL);
}
int main(void)
{
while (not_done) {
pthread_t t_id;
errno = pthread_create(&t_id, NULL, process, NULL);
if (errno) perror("pthread_create:");
}
/* There may be pending requests at this point. */
/* Just exit the main thread - not the whole program - so that remaining
requests that may still be processed can continue. */
pthread_exit(NULL);
}
Un altro esempio potrebbe essere un demone o un thread di logger che registra alcune informazioni a intervalli regolari per tutto il tempo in cui l'applicazione è in esecuzione.
Offre qualche vantaggio in termini di prestazioni rispetto a un thread unibile?
Dal punto di vista delle prestazioni, non c'è differenza tra joinable thread rispetto a detached fili. L'unica differenza è che con i thread distaccati, le sue risorse (come lo stack di thread e qualsiasi memoria heap associata e così via - esattamente ciò che costituisce quelle "risorse" è specifico dell'implementazione).
È legale non eseguire pthread_join() su un thread unibile (per impostazione predefinita)?
Sì, è legale non partecipare a un thread. pthread_join è una funzione di semplice convenienza che non deve assolutamente essere utilizzata a meno che non sia necessario. Ma nota che i thread creati sono joinable thread per impostazione predefinita.
Un esempio in cui potresti voler unirti è quando i thread eseguono un "pezzo" di lavoro che è diviso tra di loro. In tal caso, ti consigliamo di verificare che tutti i thread siano stati completati prima di procedere. Il parallelismo della task farm è un buon esempio.
O un tale thread dovrebbe sempre usare la funzione detach() prima di pthread_exit()?
Non necessario. Ma spesso vorresti decidere se vuoi un joinable o distaccato thread al momento della creazione.
Si noti che mentre un thread staccabile può essere creato impostando l'attributo PTHREAD_CREATE_DETACHED con una chiamata a pthread_attr_setdetachstate , un thread decide può decidere di staccarsi in qualsiasi momento, ad es. con pthread_detach(pthread_self()) . Inoltre, un thread con ID thread (pthread_t ) di un altro thread può staccarsi con pthread_detach(thread_id); .