Posix mutex in c

“L'uso di mutex è il metodo per prevenire le situazioni di razza che viene utilizzata più frequentemente. Mutex, che si riferisce all'esclusione reciproca, ci dà essenzialmente un blocco del fulmine che impedisce a diversi utenti di accedere e modificare contemporaneamente i dati cruciali. Ogni volta che più o più processi impiegano lo stesso processo del loro mezzo per finire la loro elaborazione, il deadlock deve essere evitato. L'argomento principale della discussione odierna sarà l'utilizzo della funzione Posix Mutex per evitare deadlock con metodi diversi con il linguaggio C in Ubuntu 20.04 Sistema. Prima di fare qualsiasi cosa con i tuoi frammenti di codice, dovremmo installare il compilatore "GCC"."

Esempio 01

Inizieremo la nostra prima illustrazione delle funzioni Mutex Posix con le intestazioni necessarie. Senza queste intestazioni, la nostra sceneggiatura di C non sarà operabile nel modo in cui la vogliamo. Il primo stdio.L'intestazione H è responsabile dell'utilizzo di input e output regolari nel codice. L'intestazione standard "stdlib" è responsabile dell'uso regolare delle funzioni della libreria standard nello snippet di codice. L'Unistd.L'intestazione h è un must per incontrare problemi relativi agli unicodi. Ecco che arriva la libreria per utilizzare le variabili e le funzioni stringa relative alla stringa in lingua c, i.e., corda.H.

Infine, la biblioteca è la "pthread.”” ”che è un must quando si desidera usare il multithreading negli snippet. Questa libreria include la creazione di thread, il giunggio del thread, il blocco del thread, lo sblocco del thread e molte altre funzioni relative a multithreading.

#includere
#includere
#includere
#includere
#includere

Dopo aver lanciato le intestazioni necessarie, inizializzeremo 2 thread usando l'oggetto "pthread_t" dalla libreria del thread. Il valore "t" verrà utilizzato come ID thread nel prossimo futuro. Quindi, una variabile intera "I" viene inizializzata su 0 e la variabile "C" è stata dichiarata per il conteggio dei thread. L'oggetto Mutex Lock "ML" è stato generato utilizzando l'oggetto pThread_mutex_t. Ecco che arriva la funzione thread "t", che bloccherà e sbloccherà il thread. Per bloccare il thread di chiamata, stiamo usando la funzione pThread_mutex_lock () usando il blocco "ML" mentre conta il numero del thread.

Le dichiarazioni printf () sono qui per raccontarci l'inizializzazione e la fine di un thread specifico. All'interno dell'inizializzazione e della fine, la funzione thread "t" è bloccata e non può essere accessibile da altri thread. Alla fine, la funzione pThread_mutex_unlock () viene utilizzata per sbloccare il thread specifico e dare accesso ad altri thread.

pThread_t t [2];
int i = 0;
int c;
pThread_mutex_lock (& ​​ml);
senza segno Long i = 0;
c += 1;
printf ("avviato %d thread ... \ n", c);
per (i = 0; i<(0xFFFFFFFF); i++)
;
sonno (5);
printf ("terminato %d thread ... \ n", c);
sonno (5);
pThread_mutex_unlock (& ​​ml);
restituire null;

La funzione principale () inizia dall'istruzione "if" che ha verificato alcune condizioni. Utilizza la funzione pThread_mutex_init () passandolo oggetto di blocco "ml" e valore null per inizializzare il blocco mutex. Se il valore restituito della funzione init () non è uguale a 0, l'istruzione printf () visualizzerà che il blocco mutex non è stato inizializzato a causa di qualche problema. Nel frattempo, il ciclo while () utilizza la condizione per la variabile "i", che dovrebbe essere inferiore a 2. Se è inferiore a 2, la funzione thread_create () verrà chiamata passando il thread ID "t" come puntatore e puntatore verso la funzione thread "t". Se il thread fosse creato correttamente, restituirebbe "0" alla variabile "E".

Nel caso in cui restituisca oltre a 0, stamperà un, i.e., Usando la funzione Strerror e incremento del valore di una variabile "i". Questa funzione è responsabile di chiamare la funzione thread t per due thread diversi. La funzione pThread_Join () utilizza l'ID thread per unirsi a loro con la funzione principale () e la funzione pThread_mutex_destroy () è qui per distruggere il blocco dopo che tutte le funzioni sono state eseguite. Il spostamento di un messaggio principale () verrà visualizzato alla fine di questo programma dopo le esecuzioni thread.

int main ()
if (pThread_mutex_init (& ml, null) != 0)
printf ("Impossibile inizializzare Mutex Lock… \ n");
Ritorno 1;

mentre io<2)
int e = pThread_create (& t [i], null, & t, null);
Se (e != 0)
printf ("Impossibile creare thread: [%s]", Strerror (e));
I ++;

pThread_Join (t [0], null);
pThread_Join (t [1], null);
pThread_mutex_destroy (& ml);
printf ("Ciao! Siamo tornati nel metodo principale ... \ n ");
restituzione 0;

Stiamo compilando il test.C file con il compilatore "GCC" e l'opzione -LpThread per l'esecuzione dei thread. L'esecuzione mostra che il primo thread ha ottenuto l'accesso alla funzione "t" e bloccato.

Dopo che il blocco è stato rilasciato dal primo thread, quindi l'accesso alla funzione T è stato dato al secondo thread e è stato bloccato e sbloccato anche.

Alla fine, entrambi i thread sono stati eseguiti e la funzione principale () ha ottenuto il controllo.

Esempio 02

Ecco un altro modo per dimostrare l'uso di Posix Mutex per bloccare e sbloccare i thread. All'interno di questo esempio, non richiediamo l'UNISTD.h intestazione, quindi non lo useremo. Altro, tutte le intestazioni sono qui, che abbiamo usato nell'esempio sopra. L'oggetto pThread_mutex_t viene utilizzato per creare un blocco mutex "ML". Il metodo principale () inizia inizializzando due thread, T1 e T2, utilizzando l'oggetto pThread_t. Utilizza due volte la funzione pThread_create () per creare thread chiamando le funzioni T1 e T2 passando loro ID di inizializzazione del thread come puntatori, i.e., T1 e T2. Nella creazione di thread, la funzione T1 e T2 è stata eseguita dopo l'altra. Ciascuna di queste funzioni è chiamata funzione test () passando 2 valori di stringa come parametri.

La funzione di test viene utilizzata qui per bloccare e sbloccare i thread specifici che la chiamano, i.e., T1 e T2. Per il blocco dei thread, viene utilizzata la funzione pThread_mutex_lock () e per lo sblocco viene utilizzata la funzione pThread_mutex_unlock (), i.e., Entrambi stanno utilizzando il blocco Mutex "ML". All'interno del processo di blocco e sblocco, le istruzioni di stampa vengono utilizzate con il sonno di 5 secondi dopo ciascuna. Il primo metodo printf () visualizzerà il primo argomento passato alla funzione di test e il secondo metodo printf () visualizzerà il secondo argomento di stringa passato alla funzione di test.

#includere
#includere
#includere
#includere
pThread_mutex_t ml;
void* test (char* p, char* q)
pThread_mutex_lock (& ​​ml);
printf ("%s… \ n", p);
sonno (5);
printf ("%s… \ n", q);
sonno (5);
pThread_mutex_unlock (& ​​ml);

void* t1 (void* z)
Test ("avviato", "1st thread");
void* t2 (void* z)
Test ("avviato", "2 ° thread");
int main ()
pThread_t T1, T2;
pThread_create (& t1, null, & t1, null);
pthread_create (& t2, null, & t2, null);
while (1)
uscita (0);

Al momento della compilazione, ti mostrerà un avvertimento, ma puoi ignorarlo per un momento.

L'esecuzione del codice compilato mostra che il primo thread è stato avviato e ha ottenuto tutte le risorse della funzione di test.

Dopo questo, il blocco è stato rilasciato e il secondo thread ha ottenuto le risorse. Dopo il secondo thread, dobbiamo uscire dall'esecuzione con forza.

Conclusione

Il concetto di mutex Posix viene brevemente spiegato per evitare deadlock nella programmazione C. Pertanto, abbiamo impiegato le funzioni PThread_mutex_lock e pthread_mutex_unlock per eseguirlo. Usando queste funzioni nei nostri frammenti di codice, abbiamo assicurato l'uso delle risorse per un thread alla volta.