Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::recursive_mutex — bloqueio repetido pela mesma thread

std::recursive_mutex permite que a mesma thread adquira várias vezes o mesmo mutex. As outras threads só o podem adquirir depois de todos os níveis de posse terem sido libertados. Cada aquisição bem-sucedida exige um desbloqueio separado.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <mutex>
std::recursive_mutex m;
std::lock_guard<std::recursive_mutex> guard(m);

std::recursive_mutex, disponível em <mutex>, proporciona posse exclusiva e permite que o respetivo proprietário adquira o mutex repetidamente. Ao contrário de std::mutex, permite que a mesma thread volte a chamar lock() ou chame try_lock() com sucesso quando já possui o mutex. Isto não significa que a posse seja partilhada entre threads.

Cada aquisição bem-sucedida aumenta o nível de aninhamento e exige uma chamada a unlock(). Até o proprietário libertar todos os níveis, o lock() de outra thread fica bloqueado e o respetivo try_lock() devolve false. O número máximo de níveis não é especificado: quando esse limite é atingido, try_lock() falha e lock() lança std::system_error.

Usa std::lock_guard<std::recursive_mutex> para associar cada aquisição à libertação no final do âmbito, incluindo quando a saída ocorre devido a uma exceção. O mutex tem de existir durante mais tempo do que os seus guards. Destruir um mutex que está a ser possuído, ou terminar uma thread enquanto ainda o possui, causa comportamento indefinido.

No exemplo, increment_twice() mantém o bloqueio externo e cada chamada a increment() acrescenta temporariamente outro nível. Os guards libertam os níveis pela ordem inversa. Uma thread é suficiente para demonstrar a aquisição repetida e um resultado determinístico; o exemplo não testa a contenção entre threads. Um mutex recursivo não substitui uma ordem de bloqueio ponderada para vários mutexes.

Exemplos

#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';
}

Resultado

2

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes