CKTIS / C++
std::recursive_mutex — blocco ripetuto da parte dello stesso thread
std::recursive_mutex consente allo stesso thread di acquisire più volte lo stesso mutex. Gli altri thread possono acquisirlo solo dopo che sono stati rilasciati tutti i livelli di possesso. Ogni acquisizione riuscita richiede uno sblocco separato.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <mutex>
std::recursive_mutex m;
std::lock_guard<std::recursive_mutex> guard(m);std::recursive_mutex, disponibile in <mutex>, offre il possesso esclusivo e consente al proprietario di acquisire ripetutamente il mutex. A differenza di std::mutex, permette allo stesso thread di chiamare di nuovo lock() o di chiamare con successo try_lock() quando possiede già il mutex. Questo non significa che il possesso sia condiviso tra thread.
Ogni acquisizione riuscita aumenta il livello di annidamento e richiede una chiamata a unlock(). Finché il proprietario non rilascia tutti i livelli, la chiamata lock() di un altro thread si blocca e il suo try_lock() restituisce false. Il numero massimo di livelli non è specificato: una volta raggiunto, try_lock() fallisce e lock() genera std::system_error.
Usa std::lock_guard<std::recursive_mutex> per associare ogni acquisizione al rilascio all’uscita dall’ambito, anche quando si esce a causa di un’eccezione. Il mutex deve avere una durata maggiore rispetto ai suoi guard. Distruggere un mutex posseduto o terminare un thread che lo possiede ancora causa un comportamento indefinito.
Nell’esempio, increment_twice() mantiene il blocco esterno e ogni chiamata a increment() aggiunge temporaneamente un altro livello. I guard rilasciano i livelli in ordine inverso. Un solo thread è sufficiente per mostrare l’acquisizione ripetuta e un risultato deterministico; l’esempio non verifica la contesa tra thread. Un mutex ricorsivo non sostituisce un ordine di blocco ponderato quando si usano più mutex.
Esempi
#include <iostream>
#include <mutex>
class Counter {
std::recursive_mutex mutex_;
int value_ = 0;
public:
void increment() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
++value_;
}
int increment_twice() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
increment();
increment();
return value_;
}
};
int main() {
Counter counter;
std::cout << counter.increment_twice() << '\n';
}
Risultato
2
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.