È valido chiamare pthread_join sul thread principale?

Question

Il comportamento di questo codice è ben definito?

#include <stdio.h> 
#include <pthread.h> 

pthread_t mt; 

void *start(void *x) 
{ 
    void *y; 
    pthread_join(mt, &y); 
    printf("joined main thread\n"); 
    return 0; 
} 

int main() 
{ 
    pthread_t t; 
    mt = pthread_self(); 
    pthread_create(&t, 0, start, 0); 
    pthread_exit(0); 
} 

Answer 1

Sì, questo è possibile. In effetti, questa possibilità è uno dei motivi principali per cui esiste pthread_detach(). Dalla documentazione POSIX per pthread_detach() (vedi man pthread_detach):

It has been suggested that a "detach" function is not necessary; the 
    detachstate thread creation attribute is sufficient, since a thread 
    need never be dynamically detached. However, need arises in at least 
    two cases: 

    1. In a cancellation handler for a pthread_join() it is nearly essen- 
     tial to have a pthread_detach() function in order to detach the 
     thread on which pthread_join() was waiting. Without it, it would 
     be necessary to have the handler do another pthread_join() to 
     attempt to detach the thread, which would both delay the cancella- 
     tion processing for an unbounded period and introduce a new call 
     to pthread_join(), which might itself need a cancellation handler. 
     A dynamic detach is nearly essential in this case. 


    2. In order to detach the "initial thread" (as may be desirable in 
     processes that set up server threads). 

Così che cosa si sta proponendo va bene secondo le norme.

Edit: solo per confermare che un ulteriore, i POSIX description of exec() stati:

Il filo iniziale nuova immagine del processo è fissato a accostabili, come se creato con l'attributo detachstate impostato PTHREAD_CREATE_JOINABLE.

Answer 2

Non riesco a immaginare il motivo per cui si dovrebbe fare questo in un mondo reale applicazione (qualcuno si prega di commentare un esempio, se si può pensare di uno), ma io non credo che sia ancora possibile. Tutte le ricerche su pthreads che ho guardato hanno sempre chiamato il join dal thread principale, non un thread secondario.

Il join richiede inoltre che il thread a cui si sta tentando di partecipare venga creato con il flag PTHREAD_CREATE_JOINABLE. Non sono stato in grado di trovare alcuna documentazione che indichi se il thread principale è stato creato come tale.

Codeguru ha una domanda simile su di esso here che può o non può aiutare a chiarire.

Se ciò che si desidera eseguire è il thread figlio che continua dopo che il thread principale è terminato, è necessario creare il thread figlio disconnesso oppure utilizzare fork/vfork in base alla piattaforma su cui si trova.

Answer 3

Il tuo approccio sembra formalmente valida a me, in particolare, dal momento che si sta facendo la pthread_exit alla fine del main.

D'altra parte non ho trovato alcuna indicazione in POSIX se la filettatura iniziale di main debba essere unificata o meno. La logica nella risposta di psmears chiede solo che main debba essere staccabile da dove è stato creato univoco.

Anche qualcos'altro dannoso potrebbe chiamare pthread_detach da una subroutine chiamata da main o così. Quindi dovresti controllare definitivamente il valore di ritorno di pthread_join per verificare un caso del genere.

anche nel codice di esempio si dispone di una gara tra la creazione di start e la cessazione di main:

• main potrebbe essere risolto prima start arriva pthread_join

Mutexing l'accesso al mt variabile dovrebbe catturare quello.