C PThread_detach Utilizzo della funzione

Come tutti sappiamo, i thread sono la parte principale di qualsiasi elaborazione mentre lavorano in qualsiasi ambiente multiprocesso. Il threading è un concetto utilizzato anche nella programmazione. Il linguaggio C viene fornito con un'API denominata "posix" per consentire l'uso di thread di diversi scopi utilizzati nel nostro pezzo di codice. Uno di questi thread è la funzione "pThread_detach ()" utilizzata per identificare o specificare un thread come disconnesso completamente. Inoltre, si assicurerà di rilasciare tutte le risorse utilizzate da quel particolare thread. All'interno di questo articolo, discuteremo dell'uso della funzione pThread_detach () nella lingua C usando Ubuntu 20.04 Sistema.

Esempio 01:

Facciamo il primo esempio per vedere il funzionamento della funzione pThread_detach. Inizia con il terminale lanciandolo, io.e., Ctrl+alt+t. Useremo comandi specifici per creare un file C, aprendolo e eseguendolo. Il primo comando è generare un nuovo file con esso, io.e., tocco. Questo nuovo file deve aprire in un tale editor in cui possiamo aggiungere codice e apportarlo anche. Abbiamo usato l'editor "nano" qui tramite il suo comando.

Abbiamo avviato l'implementazione del primo esempio con alcuni file di intestazione necessari per l'esecuzione di questo codice. Il nostro codice contiene due funzioni definite dall'utente e 1 metodo principale (). Poiché l'esecuzione parte sempre dal metodo principale (), iniziamo anche la spiegazione dal principale (). La funzione principale () è chiamata metodo "createt" nella sua prima riga. Ora il controllo è dato alla funzione "createt". Questa funzione crea un oggetto "th" per ottenere l'ID thread usando mutabile incorporato pThread_t. L'istruzione Printf mostra che siamo attualmente nel thread principale o 1^st funzione.

La funzione "pthread_create" viene utilizzata qui per creare un nuovo thread in questa funzione utilizzando il nome di un'altra funzione, i.e., Nuovo e vincolante la variabile "Th" per fare riferimento all'ID. L'istruzione "if" viene utilizzata per verificare se questa funzione principale () e altri thread appena creati sono uguali o no. Questo è stato fatto equiparando gli ID di entrambi i thread. Il riferimento mutabile "th" al nuovo thread e pThread_self () restituisce l'ID della funzione "createt". Se entrambi i thread corrispondono, stamperanno "i thread sono gli stessi"; Altrimenti, “I thread non sono gli stessi."La funzione pThread_join () garantisce che l'esecuzione del thread principale venga terminata fino a quando il nuovo thread non viene eseguito. Ora il controllo è interamente su un nuovo thread.

Nel nuovo thread, viene utilizzata la funzione di sonno. Quindi, il sistema dormirà per 10 secondi e, successivamente, avrà luogo un'ulteriore esecuzione. La funzione pThread_detach () è qui per staccare completamente il nuovo thread dalla sua funzione di chiamata, i.e., “Createt."Qui, pThread_self () viene utilizzato per scoprire l'ID di" nuovo thread "per il distacco. L'istruzione printf visualizzerà che questo thread di funzione uscirà ora. Il sistema dormirà di nuovo per i prossimi 10 secondi usando lo stesso metodo "sleep ()" di c. La funzione pThread_exit () è qui per terminare rapidamente il thread corrente, che è in questo momento "nuovo."Ora, il controllo viene restituito alla funzione" createt ". Dopo essere tornato in questo thread principale, abbiamo riscontrato una nuova istruzione printf per visualizzare che siamo tornati nella funzione "createt". Ora, dobbiamo utilizzare un'altra funzione pThread_exit () per chiudere anche il thread "createt" e restituire il controllo alla funzione principale (). Quindi, l'abbiamo fatto finora e il controllo viene restituito. Qui, il programma finisce. Quando il programma è finito, dobbiamo compilarlo con il compilatore C su Ubuntu 20.04.

È necessario assicurarsi che il compilatore C sia già configurato sulla macchina finale. Abbiamo utilizzato il compilatore GCC nel nostro shell. Quindi, il nome di un file con la parola chiave "-lpthread" viene utilizzato per compilare il codice secondo l'immagine seguente.

Dopo aver compilato il codice, dobbiamo eseguirlo per vedere l'output. Il comando per l'esecuzione è "./UN.fuori "come sotto. Quando abbiamo eseguito il file di codice, ha avviato la funzione principale e la funzione principale () chiamata funzione "createt". L'istruzione printf di "createt" ha visualizzato "thread principale" e ha creato un nuovo thread chiamato nuovo. È stato fatto un confronto di entrambi i thread e restituisce entrambi i thread non sono gli stessi. Quindi, un sistema dorme per 10 secondi.

Dopo 10 secondi, si unisce al thread creato nuovo. Il nuovo thread è stato staccato dalla funzione "createt" e visualizzato che siamo nella funzione thread "nuova". Il sistema dorme di nuovo per i successivi 10 secondi ed esce dal nuovo thread.

Ora, il controllo è finito al thread "createt" e si è concluso che siamo tornati nel thread principale. Dopo aver completato il thread "createt", la funzione principale () è stato dato il controllo. Quindi, il programma termina qui con successo.

Esempio 02:

Diamo uno sguardo abbastanza diverso all'esempio della funzione pThread_detach in c. Abbiamo avviato il nostro codice C con le stesse intestazioni della biblioteca con la parola chiave #include per rendere il nostro codice eseguibile. Funzione 1 main () e 1 funzione definita dall'utente denominata "nuovo". La funzione "nuova" verrà utilizzata come funzioni del thread. Stiamo iniziando la spiegazione da un metodo principale (). Pthead_t mutabile sta dichiarando la variabile "th" per ottenere l'ID thread di un nuovo thread. L'istruzione Printf mostra che abbiamo avviato la funzione principale e richiede 10 secondi usando il metodo "Sleep". La prossima stampa visualizza che verrà creata una funzione thread e la funzione pThread_create () di posix viene utilizzata finora per questo motivo.

Il "th" viene utilizzato come parametro per la funzione di creazione del nuovo thread per ottenere l'ID di un nuovo thread. La funzione pThread_join () è qui per sospendere completamente l'esecuzione di un metodo principale () fino al nuovo thread, i.e., Nuovo, sta eseguendo. Ora, la nuova funzione viene avviata. La funzione pThread_detach () è qui per staccare completamente questa funzione dalla funzione principale () riprendendo le sue risorse. La funzione pThread_exit () assicurerà che il nuovo thread non venga più eseguito. Pertanto, la sua istruzione printf non verrà eseguita. Il thread principale () verrà terminato dopo aver eseguito la sua funzione pThread_exit ().

Cominciamo con la compilazione del codice con GCC. Per fortuna! Ha avuto successo.

Quindi, abbiamo utilizzato lo stesso "./UN.Istruzioni anche qui. La funzione principale () ha iniziato a eseguire prima come output dell'istruzione di stampa. Ora, il sistema dorme per 10 secondi.

Dopo 10 secondi, l'istruzione di stampa successiva viene eseguita e visualizzata che viene creata il nuovo thread. Il controllo è finito al nuovo thread ed è staccato dalla funzione principale () senza eseguire la sua istruzione printf. Pertanto, il nostro output è qualcosa di simile.

Conclusione:

Quindi, si trattava di usare la funzione pThread_detach di Posix in C per staccare completamente un thread dal thread di chiamata principale. Mantenendolo abbastanza semplice e spiegando brevemente le illustrazioni, abbiamo fatto del nostro meglio per farti capire questi esempi implementati in Ubuntu 20.04.