Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

std::shared_mutex — zdieľané a výhradné zamykanie

std::shared_mutex umožňuje, aby zámok súčasne vlastnilo viacero vlákien v zdieľanom režime, alebo aby ho výhradne vlastnilo jedno vlákno. Na čítanie používajte std::shared_lock a na zápis std::unique_lock; pri každom prístupe k chráneným údajom dodržiavajte rovnaký protokol.

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

Syntax

#include <shared_mutex>
#include <mutex>

std::shared_mutex m;
// In separate scopes:
{ std::shared_lock<std::shared_mutex> read_lock(m); }
{ std::unique_lock<std::shared_mutex> write_lock(m); }

std::shared_mutex deklarovaný v <shared_mutex> je nerekurzívny mutex. Zdieľaný režim povoľuje súčasne viacero vlastníkov; výhradný režim vylučuje všetkých ostatných vlastníkov. Obvyklý protokol spočíva v čítaní so zdieľaným vlastníctvom a v úpravách s výhradným vlastníctvom. Mutex sám prístup k premenným nekontroluje: váš kód musí tento protokol dôsledne dodržiavať.

lock() a unlock() spravujú výhradné vlastníctvo, zatiaľ čo lock_shared() a unlock_shared() spravujú zdieľané vlastníctvo. Blokujúce operácie čakajú, kým nebude možné vlastníctvo získať. try_lock() a try_lock_shared() sa o získanie pokúšajú bez čakania a vracajú bool; môžu zlyhať aj bez skutočnej prekážky, takže false nedokazuje, že mutex vlastní iné vlákno.

Namiesto ručného odomykania uprednostnite RAII: pre čitateľov použite std::shared_lock<std::shared_mutex> z <shared_mutex> a pre zapisujúcich std::unique_lock<std::shared_mutex> z <mutex>. Tieto objekty uvoľnia vlastnený zámok pri opustení svojho rozsahu, aj počas propagácie výnimky. Zdieľané vlastníctvo neposkytuje výhradný prístup potrebný na bežné úpravy zdieľaných údajov.

Nepokúšajte sa znova získať žiadny druh vlastníctva vo vlákne, ktoré už vlastní ten istý mutex: správanie je nedefinované. Patrí sem aj pokus získať výhradné vlastníctvo bez uvoľnenia zdieľaného. Odomknutie a opätovné zamknutie nie je atómová zmena režimu — medzičasom sa údaje môžu zmeniť. Neničte vlastnený mutex a nedovoľte, aby sa vlákno skončilo, kým mutex stále vlastní.

Príklad oddeľuje zápis od čítania pomocou join() a každý prístup k value chráni príslušným zámkom. Čitatelia môžu bežať súbežne, ale nemusia; výsledky ukladajú do samostatných premenných. Výpis po oboch volaniach join() vytvorí deterministický výsledok 42 42.

Príklady

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

int main() {
    std::shared_mutex mutex;
    int value = 0;

    std::thread writer([&] {
        std::unique_lock<std::shared_mutex> lock(mutex);
        value = 42;
    });
    writer.join();

    int first = 0;
    int second = 0;
    std::thread reader1([&] {
        std::shared_lock<std::shared_mutex> lock(mutex);
        first = value;
    });
    std::thread reader2([&] {
        std::shared_lock<std::shared_mutex> lock(mutex);
        second = value;
    });
    reader1.join();
    reader2.join();

    std::cout << first << ' ' << second << '\n';
}

Výsledok

42 42

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje