C pThread_mutex_lock Utilizzo della funzione

Come suggerisce il nome, la funzione "pthread_mutex_lock" deve essere usata per bloccare qualcosa. La libreria POSIX di C ha inventato questa funzione per bloccare un thread specifico che può essere utilizzato come risorsa condivisa per qualche altra funzione in un programma. È necessario evitare deadlock durante l'esecuzione quando due o più funzioni utilizzano lo stesso thread della loro risorsa per il completamento dell'esecuzione. Pertanto, discuteremo dell'uso della funzione "pThread_mutex_lock" della libreria C POSIX in Ubuntu 20.04 Sistema.

Esempio 01:

Cominciamo con il primo esempio per vedere la funzione mutex_lock () di posix nel codice c. Abbiamo iniziato con la creazione di file con le istruzioni "touch" di Ubuntu nella sua shell. Questo file di recente generazione è disponibile nella cartella Home Linux. Per aggiungere il codice in questo file, devi aprirlo all'interno di un editor di Ubuntu I.e., testo, nano o vim. Stiamo usando il nano editor qui per la nostra creazione di codice. Entrambi i comandi sono elencati nell'immagine.

Stiamo iniziando il nostro codice C con alcune intestazioni C. Questi pacchetti di intestazione includono l'uso di input-output standard per codice, librerie standard, intestazioni di stringa e libreria thread POSIX. Abbiamo inizializzato un oggetto thread posix "th" della dimensione 3 i.e. Creerà solo 3 thread usando IDS.

Dopo questo, le variabili di tipo intero vengono dichiarate i.e., "Io" e conta ". La variabile "i" è inizializzata su 0. Ecco che arriva la variabile pThread_mutex_t per dichiarare il "blocco" per un thread. Sebbene, l'esecuzione inizi dal metodo principale () dobbiamo prima guardare la funzione del thread. Questa funzione è chiamata come sezione critica del nostro codice a causa della funzione "mutex_lock". All'inizio della funzione thread, la funzione pThread_mutex_lock utilizza la variabile di blocco per bloccare il thread particolare usando il suo "id" passato dalla funzione principale () metodo pThread_create ().

Ora, nessun altro thread può usare questo thread fino a quando questo thread non è sbloccato. Quindi, continuerà a elaborare. La variabile di tipo lungo "i" è inizializzata su 0 per l'uso nel loop "per". La variabile "conta" è stata incrementata di 1. La variabile di conteggio viene utilizzata all'interno dell'istruzione di stampa per farci sapere che il "thread1" viene avviato ora. Per "Loop" sarà inizializzato qui per dare un momento di interruzione all'esecuzione del thread. Dopodiché, l'istruzione di stampa ci farà sapere che il thread 1 sarà finito.

La funzione pThread_mutex_unlock () viene utilizzata rispetto alla funzione pThread_mutex_lock () per sbloccare il thread numero 1. Il controllo va al metodo principale (). La funzione principale () continua a creare la funzione thread fino a quando il conteggio non raggiunge 3. Ecco che arriva il turno del metodo principale () dopo la creazione di 3 thread, blocca, sbloccare ed uscire.

La funzione principale () è inizializzata con una variabile intera "err". L'istruzione "if" viene utilizzata qui per verificare se l'inizializzazione del thread Mutex "L" non è riuscita usando la funzione "pThread_mutex_init ()" di Posix. Se l'inizializzazione non riesce, stamperà il messaggio particolare dell'istruzione di stampa. Il ciclo "while" è qui per vedere la condizione i.e. "Io" meno di 3. Confermerà che il valore di "i" è inferiore a 3 e quindi, continua a creare un thread. Ogni thread verrà bloccato quando viene chiamato e fino ad allora non è possibile creare nessun altro thread.

Se abbiamo ricevuto un errore nel thread, visualizzeremo quell'errore nella shell convertendolo in stringa usando il metodo "Strerror". La funzione pThread_join () viene utilizzata per riprendere tutte le risorse fornite ai thread. Infine, la funzione "pThread_mutex_destroy ()" viene utilizzata per distruggere l'oggetto Lock. Il nostro programma termina qui.

Il file è stato compilato e non abbiamo errori. Durante l'esecuzione, la funzione principale () è iniziata e ha creato un thread 1.

Dopo un po ', a causa di Lock, il thread 1 ha completato la sua esecuzione e terminato. Successivamente, la funzione principale () ha creato il thread 2 ed è stata avviata.

Dopo che il thread 2 è stato completamente eseguito, il blocco è stato terminato e la funzione principale () ha creato un ultimo thread i.e., 3^Rd filo.

Dopo aver eseguito completamente il terzo thread, il blocco viene rilasciato e il controllo viene restituito al metodo principale.

Esempio 02:

Facciamo un altro esempio per vedere il funzionamento della funzione "pThread_mutex_lock ()" di Posix. Il codice è stato avviato con gli stessi file di intestazione.

Dopo i file di intestazione, abbiamo creato una funzione Mutex Lock. Ci arrivano tre funzioni. Due funzioni di thread e 1 è la funzione collegata. Thread1 e thread2 stanno prendendo input dalla funzione principale () i.e. thread oggetti th1 e th2. Entrambe le funzioni del thread chiamano il metodo show () e passano due stringhe nel suo parametro. Quando inizia la funzione "Show", si blocca con l'uso della funzione "pThread_mutex_lock ()" utilizzando l'oggetto Mutex Lock. La prima dichiarazione di stampa sta prendendo il primo argomento e la mostra. Quindi, dorme per 1 secondo e il secondo valore dell'argomento verrà visualizzato tramite la clausola di stampa. Nell'ultima riga, il blocco è stato rilasciato utilizzando la funzione "pThread_mutex_unlock ()" utilizzando l'oggetto Lock.

La funzione principale () viene avviata con la creazione di due oggetti per i thread i.e. Th1 e Th2. Due thread sono stati creati dalla funzione "pthread_create" passando Th1 e Th2 nei parametri. Il ciclo "while" è usato per correre e non finire nemmeno per un secondo. Quindi, il programma continua a elaborare se stesso.

Il codice è stato compilato per primo con l'aiuto del compilatore "GCC" in Ubuntu 20.04.

Quando il codice è stato eseguito, mostra () metodo chiamato Utilizzo della funzione thread1 e thread2 uno dopo l'altro. Il programma non si è fermato dopo che i thread sono stati eseguiti. Quindi, dobbiamo fermare l'esecuzione con forza usando il collegamento "Ctrl+Z".

Per evitare che il tuo sistema effettui l'elaborazione non-stop, dobbiamo rimuovere il ciclo "mentre" dal codice nel metodo principale (). La frase di ritorno 0 è stata sostituita con il ciclo "while".

Ora, questo programma è pronto per essere compilato ed eseguito. Quindi, abbiamo compilato questo programma con un compilatore "GCC". Dopodiché, l'esecuzione ha avuto luogo. Puoi vedere che il programma si è concluso dopo l'esecuzione di due thread. Il thread1 ha funzionato e la funzione show () si è bloccata durante l'esecuzione. Dopo l'esecuzione, è stato rilasciato e thread2 è stato eseguito. La funzione "Show" è chiamata al suo interno e ha superato alcuni parametri. La funzione "show ()" si è bloccata e non si è rilasciata fino a quando l'esecuzione non è stata eseguita e la funzione mutex_lock non viene chiamata. Successivamente, il controllo viene restituito al metodo principale () e il programma termina.

Conclusione

Questo riguardava tutto ciò che possiamo fare per farti capire l'uso della funzione pThread_mutex_lock nel codice c. Avevamo provato due programmi estremamente diversi per renderti comprensibile per te e spiegato sia gli esempi in modo abbastanza breve che semplicemente. Siamo abbastanza ottimisti sul fatto che questo articolo sarà ottimo per ogni utente C.