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 di loro. Nel multithreading, il thread è solo per eseguire l'operazione di lettura che non crea problemi poiché il thread non viene influenzato da ciò che gli altri thread stanno facendo in quel momento. Ma se questi thread devono condividere le risorse tra di loro, un thread può modificare i dati in quel momento che crea il problema. Per affrontare questo problema, abbiamo il C++ 'Mutex' che impedisce l'accesso di più risorse al nostro codice/oggetto fornendo la sincronizzazione che afferma che l'accesso all'oggetto/codice può essere fornito solo a un thread alla volta, in modo che più thread non siano in grado di accedere a quell'oggetto contemporaneamente.
Procedura:
Impareremo come interrompere l'accesso di più thread a un oggetto contemporaneamente utilizzando il blocco mutex. Parleremo della sintassi del blocco mutex, cos'è il threading multiplo e come possiamo affrontare i problemi causati dal threading multiplo usando 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 impedire l'accesso di più thread contemporaneamente al nostro oggetto o codice, possiamo usare la seguente sintassi:
$ standard :: mute mu_x
$mut_x. serratura ( ) ;
Nome_funzione vuoto ( ) {
$ // il codice che vogliamo nascondere dai thread multipli verrebbe scritto qui
$mut_x. sblocca ( ) ;
}
Ora useremo questa sintassi nell'esempio fittizio e nello pseudo codice (che non possiamo semplicemente eseguire come è nell'editor di codice) per farti sapere come possiamo usare esattamente questa sintassi come menzionato di seguito:
$ standard :: mute mu_x
Blocco vuoto ( ) {
$mut_x. serratura ( ) ;
$ standard :: cout << 'ciao' ;
$mut_x. sblocca ( ) ;
}
Esempio:
In questo esempio, proviamo a creare prima l'operazione multithread e quindi circondare questa operazione con blocco e sblocco mutex per fornire la sincronizzazione dell'operazione con il codice o l'oggetto creato. Mutex si occupa di condizioni di gara che sono valori piuttosto imprevedibili e dipendono dal cambio di thread che sono consapevoli del tempo. Per implementare l'esempio per mutex, dobbiamo prima importare le librerie importanti e richieste dai repository. Le librerie richieste sono:
$ # includi
$ # includi
$ # 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 permette di implementare sia il blocco mutex che lo sblocco nel codice. Usiamo il “#include” perché questo permette tutti i programmi relativi alla libreria inclusi nel codice.
Ora, dopo aver completato il passaggio precedente, definiamo la classe mutex o una variabile globale per il mutex usando std. Quindi, creiamo una funzione per il blocco e lo sblocco mutex che potremmo chiamare in seguito nel codice. In questo esempio, chiamiamo questa funzione come blocco. Nel corpo della funzione di blocco, chiamiamo prima 'mutex.lock()' e iniziamo a scrivere la logica del codice.
Il mutex.lock() nega l'accesso agli altri thread per raggiungere il nostro oggetto o codice creato in modo che solo un thread possa leggere il nostro oggetto alla volta. Nella logica, eseguiamo un ciclo for che viene eseguito sull'indice da 0 a 9. Visualizziamo i valori nel ciclo. Una volta che questa logica è stata creata nel blocco mutex al termine della sua operazione o dopo essere usciti dalla logica, chiamiamo il metodo 'mutex.unlock()'. Questa chiamata al metodo ci consente di sbloccare l'oggetto creato dal blocco mutex poiché l'accesso dell'oggetto a un singolo thread è stato fornito in precedenza e una volta che l'operazione su quell'oggetto è stata eseguita da un thread alla volta. Ora vogliamo che anche gli altri thread accedano a quell'oggetto o codice. Altrimenti, il nostro codice si sposta nella situazione di 'deadlock' che fa sì che l'oggetto creato con il mutex rimanga nella situazione bloccata per sempre e nessun altro thread sarebbe in grado di accedere a quell'oggetto. Quindi, un'operazione incompleta continua a essere eseguita. Successivamente, usciamo dalla funzione di blocco e passiamo a quella principale.
Principalmente, mostriamo semplicemente il nostro mutex creato creando i tre thread usando 'std :: thread thread_name (chiamando la funzione di blocco già creata qui in cui abbiamo creato il mutex)' con i nomi thread1, thread2 e thread3, ecc In questo modo vengono creati i tre thread. Quindi uniamo questi tre thread da eseguire contemporaneamente chiamando il 'thread_name. unisciti ()”. E poi, restituiamo il valore uguale a zero. La spiegazione dell'esempio precedentemente menzionata è implementata nella forma del codice che può essere mostrato 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 del 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 usata in C++. Abbiamo discusso quali sono le applicazioni multithreading, quali problemi dobbiamo incontrare nelle applicazioni multithreading e perché è necessario implementare il mutex per le applicazioni multithreading. Abbiamo quindi discusso la sintassi per il mutex con l'esempio fittizio usando lo pseudo-codice. Quindi, abbiamo implementato un esempio completo sulle applicazioni multithreading con il mutex sul visual studio C++.