C ++ stdmutex/
Funzionante di mutex in c++
Considera una situazione in cui un thread esegue una sezione di codice che un mutex ha bloccato. Ora, se lo Scheduler decide di modificare il contesto, tutti gli altri thread preparati a eseguire la stessa zona sono sbloccati. Solo un thread di tutti gli altri sarebbe in grado di raggiungere questo obiettivo, ma se questo thread tentasse di eseguire una parte bloccata del codice, andrebbe di nuovo a dormire.
Ci saranno ripetuti switch di contesto ma fino a quando il blocco mutex sulla sezione bloccato del codice sarà liberato, nessun thread sarà in grado di eseguirlo. Un thread che ha bloccato un mutex non può rilasciarlo.
Pertanto, ciò si assicura che una volta che un thread blocca una parte del codice, nessun altro thread può eseguire quella regione fino a quando il thread bloccato non lo sblocca.
Quindi, mentre funziona su risorse condivise, questo sistema si assicura che i thread siano sincronizzati.
Invocando le due seguenti funzioni, viene inizializzato un mutex e viene quindi raggiunto un blocco: Il primo metodo inizializza un mutex e la seconda funzione consente il blocco di qualsiasi sezione cruciale del codice.
# Int pThread_mutex_init (pThread_mutex_trylock *limita mutex, const pthread_mutexattribute_trylock *limitare l'attributo):
Fornisce un mutex le caratteristiche definite dall'attributo e un riferimento a un altro mutex. La proprietà Mutex predefinita (non recursiva) viene utilizzata se l'attributo è nullo. Se PThread Mutex init () ha esito positivo, restituisce 0 e inizializza e sblocca lo stato di Mutex. Pthread mutex init () restituisce -1 se non ha successo.
# int pThread_mutex_lock (pThread_mutex_trylock *mutex):
Classifica un mutex e blocca un oggetto mutex. Il thread esistente dovrebbe attendere che Mutex si sblocchi se è stato precedentemente bloccato da un altro thread. Un mutex è bloccato dal thread che lo ha bloccato e quel thread continua ad essere il proprietario di Mutex fino a quando quel thread non lo sblocca. Il modo in cui viene utilizzato un blocco può variare a seconda che il mutex abbia la caratteristica ricorsiva o meno. Quando lo stesso thread blocca lo stesso tipo di mutex più di una volta, il conteggio viene aumentato e non viene creata alcun thread di attesa.
Per ridurre il conteggio a zero, il thread di proprietà deve effettuare un numero uguale di chiamate a pThread_mutex_unlock ().In caso di successo, la funzione pThread_mutex_lock () restituisce 0. PThread_mutex_lock () restituisce -1 se fallisce.
Eseguendo le due azioni indicate di seguito, il mutex può essere sbloccato e distrutto. Il blocco può essere aperto usando la prima tecnica e può anche essere distrutto in modo che non possa essere utilizzato in futuro.
# int pThread_mutex_unlock (pthread_mutex_trylock *mutex):
L'oggetto mutex viene rilasciato. Se diversi o più thread fanno la fila per bloccare il mutex, pThread mutex sblock () obbliga uno dei thread a farlo. Lo costringe anche a fuggire da pThread mutex lock () con l'oggetto mutex che aveva ricevuto in precedenza. Il mutex si sblocca a meno che nessun thread non sia in attesa e al momento non ha proprietario. L'uso del blocco può cambiare se il mutex ha la caratteristica ricorsiva.
Quando lo stesso thread blocca un dato mutex più di una volta, il conteggio viene ridotto allo sblocco e non viene creata alcun thread di attesa per mantenere il blocco. Il mutex viene rimosso e qualsiasi thread di attesa viene pubblicato se il conteggio è sceso a zero. PThread_mutex_unlock () restituisce 0 in caso di successo. PThread_mutex_unlock () restituisce -1 in caso di errore.
int pThread_mutex_destroy (pThread_mutex_trylock *mutex): Rimuove un oggetto mutex. A volte viene definito un identificatore mutex dal sistema. I mutex sono utilizzati per salvaguardare le risorse condivise. Il mutex viene inizializzato con un valore errato ma pThread Mutex init consente la re-inizizzazione (). Il valore di ritorno riuscito di pThread_mutex_destroy () è 0. PThread_mutex_destroy () restituisce -1 in caso di guasto.
Esempio di mutex in c++
Un'illustrazione di come viene realizzata la sincronizzazione del thread con i mutex.
Qui, abbiamo dato per la prima volta la dimensione dell'ID thread "3". Successivamente, abbiamo inizializzato il contatore variabile che registra la frequenza con i thread che vengono eseguiti. Quindi, abbiamo creato il blocco oggetto per pThread_mutex_lock. Successivamente, abbiamo stabilito una funzione "Mutex_Func" in cui abbiamo preso il riferimento di blocco e inizializzato la variabile "M" con zero. Il valore incrementale viene inserito nel contatore variabile.
Ora abbiamo definito la funzione principale di questo script. Le due variabili sono dichiarate, una per Mutex come "M" e una per il fallimento di Mutex come "errore". Quando il metodo "Mutex func ()" utilizza la risorsa condivisa "contatore", lo stesso mutex è bloccato. L'agentico mutex viene sbloccato dopo la funzione "mutex_func ()". Il mutex viene eliminato una volta che entrambi i thread hanno completato la funzione principale. Si noti che vengono eseguite rispettivamente solo due attività.
Nell'output, puoi notare che un thread è iniziato. Una volta che il thread in esecuzione non viene distrutto, l'altro compito che non è iniziata è il compito. Pertanto, questa volta entrambi i lavori di lavoro iniziano e finali. Pertanto, l'uso della sincronizzazione del thread abilitato Mutex.
Conclusione
Possiamo bloccare l'oggetto che contiene la funzionalità essenziale della nostra applicazione usando un mutex. Inoltre, questo evita dati incoerenti, il che è cruciale per le applicazioni in tempo reale. Come il modo in cui la sincronizzazione è implementata in altri linguaggi di programmazione, viene impiegato Mutex. Abbiamo incorporato un esempio per spiegare il concetto di std :: mutex anche nel linguaggio di programmazione C ++.