Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

std::unique_lock — elastyczne zarządzanie blokadą muteksu

std::unique_lock to dostępny w <mutex> przenoszalny, ale niekopiowalny obiekt RAII zarządzający blokadą muteksu. Pozwala odroczyć blokowanie, odblokować muteks przed końcem zakresu i ponownie go zablokować. Destruktor odblokowuje muteks tylko wtedy, gdy obiekt nadal posiada blokadę.

Wersja: C++23; repository compiler flag, production runtime not attested

Składnia

#include <mutex>
std::unique_lock<Mutex> lock(mutex);
std::unique_lock<Mutex> lock(mutex, std::defer_lock);

std::unique_lock<Mutex> z nagłówka <mutex> zarządza własnością blokady, a nie czasem życia muteksu. Stosuje RAII: destruktor wywołuje unlock() na muteksie, jeżeli obiekt posiada blokadę, także przy opuszczaniu zakresu wskutek wyjątku. Muteks musi istnieć tak długo, jak obiekt pozostaje z nim powiązany. Obiekt można przenosić, ale nie kopiować.

Konstruktor z samym muteksem wywołuje jego lock(). Znacznik std::defer_lock tylko ustanawia powiązanie, bez blokowania; std::try_to_lock wykonuje nieblokującą próbę, której wynik sprawdzisz przez owns_lock() lub konwersję do bool. std::adopt_lock wymaga, aby bieżący wątek już posiadał wyłączną blokadę muteksu; nie jest sposobem na jej zdobycie.

lock() i unlock() pozwalają zmieniać stan przed końcem zakresu. Nie wywołuj lock(), gdy obiekt już posiada blokadę, ani unlock(), gdy jej nie posiada. Mutex musi spełniać wymagania BasicLockable; operacje próbne wymagają dodatkowo Lockable, a try_lock_for() i try_lock_until() — TimedLockable. Samo użycie std::unique_lock nie dodaje muteksowi obsługi limitów czasu.

Nie myl release() z unlock(): release() zwraca wskaźnik do muteksu i usuwa powiązanie, ale nie odblokowuje muteksu. Odpowiedzialność za ewentualne odblokowanie przechodzi na kod wywołujący. Przykład pokazuje odroczenie blokowania, ręczne odblokowanie i ponowne zablokowanie, po którym destruktor zwalnia blokadę. Jeden wątek zapewnia deterministyczny wynik; przykład nie demonstruje rywalizacji wątków.

Przykłady

#include <iostream>
#include <mutex>

int main() {
    std::mutex mutex;
    int value = 0;
    {
        std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
        std::cout << std::boolalpha << lock.owns_lock() << '\n';
        lock.lock();
        ++value;
        std::cout << lock.owns_lock() << ' ' << value << '\n';
        lock.unlock();
        std::cout << lock.owns_lock() << '\n';
        lock.lock();
    }
    std::cout << value << '\n';
}

Wynik

false
true 1
false
1

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła