CKTIS / C++
std::shared_mutex — deljeno in izključno zaklepanje
std::shared_mutex omogoča, da ima več niti hkrati deljeno lastništvo zaklepa ali da ima ena nit izključno lastništvo. Za branje uporabite std::shared_lock, za pisanje pa std::unique_lock; pri vsakem dostopu do zaščitenih podatkov upoštevajte isti protokol.
Različica: C++23; repository compiler flag, production runtime not attested
Sintaksa
#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, deklariran v <shared_mutex>, je nerekurzivni mutex. Deljeni način dovoljuje več lastnikov hkrati; izključni način izloči vse druge lastnike. Običajni protokol je branje z deljenim lastništvom in spreminjanje z izključnim lastništvom. Mutex sam ne nadzoruje dostopa do spremenljivk: vaša koda mora ta protokol dosledno upoštevati.
lock() in unlock() upravljata izključno lastništvo, lock_shared() in unlock_shared() pa deljeno lastništvo. Blokirne operacije čakajo, dokler lastništva ni mogoče pridobiti. try_lock() in try_lock_shared() ga poskusita pridobiti brez čakanja ter vrneta bool; lahko spodletita tudi brez dejanske ovire, zato false ne dokazuje, da mutex ima druga nit.
Namesto ročnega odklepanja raje uporabite RAII: za bralce std::shared_lock<std::shared_mutex> iz <shared_mutex>, za pisce pa std::unique_lock<std::shared_mutex> iz <mutex>. Ti objekti sprostijo zaklep, ki ga imajo, ob koncu svojega obsega, tudi med širjenjem izjeme. Deljeno lastništvo ne zagotavlja izključnosti, potrebne za običajno spreminjanje deljenih podatkov.
Ne poskušajte znova pridobiti nobene vrste lastništva v niti, ki že ima isti mutex: vedenje je nedefinirano. To vključuje poskus pridobitve izključnega lastništva, ne da bi prej sprostili deljeno. Odklepanje in ponovno zaklepanje ni atomska sprememba načina — podatki se lahko vmes spremenijo. Ne uničite mutexa, ki je v lasti niti, in ne dovolite, da se nit konča, dokler ima mutex še vedno v lasti.
Primer loči pisanje od branja z join() in vsak dostop do value zaščiti z ustreznim zaklepom. Bralci se lahko izvajajo sočasno, vendar se jim ni treba; rezultate shranijo v ločene spremenljivke. Izpis po obeh klicih join() zagotovi deterministični rezultat 42 42.
Primeri
#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';
}
Rezultat
42 42
Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.
Viri
- C++ working draft — Concurrency support library [thread]
- C++ working draft — Class shared_mutex [thread.sharedmutex.class]
- C++ working draft — Shared mutex types [thread.sharedmutex.requirements]
- C++ working draft — Class template shared_lock [thread.lock.shared]
- C++ working draft — Class template unique_lock [thread.lock.unique]