Blocco mutex c ++

C ++ è noto per essere uno dei linguaggi di programmazione più veloci con buone prestazioni, alta precisione e un adeguato sistema di gestione della memoria. Questo linguaggio di programmazione supporta anche l'esecuzione simultanea di più thread con la condivisione di più risorse tra loro. In Multithreading, il thread è solo per eseguire l'operazione di lettura che non presenta problemi poiché il thread non viene influenzato da ciò che gli altri thread stanno facendo in quel momento. Ma se questi thread dovevano condividere le risorse tra loro, un thread può modificare i dati in quel momento, il che rende il problema. Per affrontare questo problema, abbiamo il "mutex" C ++ che impedisce l'accesso di più risorse verso il nostro codice/oggetto fornendo la sincronizzazione che afferma che l'accesso all'oggetto/codice può essere fornito a un solo thread contemporaneamente, in modo che multipli di thread non sarebbero in grado di accedere a quell'oggetto contemporaneamente.

Procedura:

Saperemo come possiamo fermare l'accesso di più thread a un oggetto in un singolo momento usando Mutex Lock. Parleremo della sintassi del blocco Mutex, di cosa è più threading e di come possiamo affrontare i problemi causati da più threading utilizzando il blocco Mutex. Quindi, faremo un esempio del threading multiplo e implementeremo il blocco mutex su di essi.

Sintassi:

Se vogliamo imparare come possiamo implementare il blocco Mutex in modo da poter impedire l'accesso di più thread contemporaneamente verso il nostro oggetto o codice, potremmo utilizzare la seguente sintassi:

$ std :: mutex mut_x
$ mut_x. serratura ();
Void func_name ()
Codice $ // Vogliamo nasconderci dai thread multipli verrebbero scritti qui
$ mut_x. sblocchi ();

Ora useremo questa sintassi sull'esempio fittizio e nel codice pseudo (che non possiamo semplicemente eseguire come lo è nell'editor di codice) per farti sapere come possiamo usare esattamente questa sintassi come menzionato nel seguente:

$ std :: mutex mut_x
Void block ()
$ mut_x. serratura ();
$ std :: cout << “hello”;
$ mut_x. sblocchi ();

Esempio:

In questo esempio, proviamo prima a creare l'operazione multithread e quindi circondare questa operazione con Mutex Lock e sblocca per fornire la sincronizzazione del funzionamento al codice o all'oggetto creato. Mutex si occupa delle condizioni di razza che sono i valori abbastanza imprevedibili e dipendono dalla commutazione dei thread che sono consapevoli del tempo. Per implementare l'esempio per Mutex, dobbiamo prima importare le librerie importanti e richieste dai repository. Le biblioteche richieste sono:

$ # include
$ # include
$ # include

La libreria "iostream" ci fornisce una funzione per visualizzare i dati come cout, leggere i dati come CIN e terminare l'istruzione come endl. Usiamo la libreria "thread" per utilizzare i programmi o le funzioni dai thread. La libreria "Mutex" ci consente di implementare sia il blocco Mutex che uno sblocco nel codice. Usiamo il "# include" perché ciò consente tutti i programmi relativi alla libreria inclusi nel codice.

Ora, dopo che il passaggio precedente è terminato, definiamo la classe Mutex o una variabile globale per Mutex usando la MTD. Quindi, creiamo una funzione per il blocco Mutex e sblocca che potremmo chiamare in seguito nel codice. In questo esempio, nominiamo questa funzione come blocco. Nel corpo della funzione di blocco, chiamiamo prima "Mutex.Lock () ”e inizia a scrivere la logica del codice.

Il mutex.Lock () nega l'accesso degli altri thread per raggiungere il nostro oggetto o codice creato in modo che un solo thread possa leggere il nostro oggetto contemporaneamente. Nella logica, eseguiamo un ciclo per il ciclo che funziona sull'indice da 0 a 9. Visualizziamo i valori nel ciclo. Una volta creata questa logica nel blocco Mutex dopo aver effettuato il suo funzionamento o dopo essere uscito dalla logica, chiamiamo "Mutex.Metodo di sblocco () ". Questa chiamata del metodo ci consente di sbloccare l'oggetto creato da Mutex Lock poiché l'accesso dell'oggetto a un singolo thread è stato fornito in precedenza e una volta che l'operazione su quell'oggetto viene eseguita da un thread contemporaneamente. Ora vogliamo che gli altri thread accedano anche a quell'oggetto o al codice. Altrimenti, il nostro codice si sposta nella situazione "deadlock" che fa sì che l'oggetto creato con il mutex rimanga per sempre nella situazione bloccata e nessun altro thread sarebbe in grado di accedere a quell'oggetto. Quindi, un'operazione incompleta continua a eseguire. Dopo questo, usciamo dalla funzione di blocco e ci spostiamo al principale.

Nella principale, visualizziamo semplicemente il nostro mutex creato creando i tre thread utilizzando "STD :: thread thread_name (chiamando la funzione blocco già creata qui in cui abbiamo creato mutex)" con i nomi thread1, thread2 e thread3, ecc. In questo modo, vengono creati i tre thread. Inseriamo quindi questi tre thread da eseguire contemporaneamente chiamando il "thread_name. join () "metodo. E poi, restituiamo il valore pari a zero. La spiegazione precedentemente menzionata dell'esempio è implementata sotto forma del codice che può essere mostrata nella figura seguente:

Nell'output del codice, possiamo vedere l'esecuzione e la visualizzazione di tutti e tre i thread uno per uno. Possiamo vedere anche se la nostra applicazione rientra nella categoria di multithreading. Tuttavia, nessuno dei thread ha sovrascritto o modificato i dati e condiviso la risorsa modificata a causa dell'implementazione del mutex del "blocco funzione".

Conclusione

Questa guida fornisce una spiegazione dettagliata del concetto della funzione mutex utilizzata in c++. Abbiamo discusso quali sono le applicazioni multithreading, quali problemi abbiamo da incontrare nelle applicazioni multithreading e perché dobbiamo implementare il mutex per le applicazioni multithreading. Abbiamo quindi discusso della sintassi per Mutex con l'esempio fittizio usando lo pseudo-codice. Quindi, abbiamo implementato un esempio completo sulle applicazioni multithreading con Mutex su C ++ Visual Studio.