CKTIS / C++
std::counting_semaphore: omejevanje sočasnih dostopov
std::counting_semaphore vzdržuje število dovoljenj; acquire eno porabi, release pa jih vrne in lahko odblokira čakajočo nit.
Različica: C++23
Sintaksa
template<std::ptrdiff_t LeastMaxValue = /* implementation-defined */>
class counting_semaphore {
public:
static constexpr std::ptrdiff_t max() noexcept;
constexpr explicit counting_semaphore(std::ptrdiff_t desired);
void release(std::ptrdiff_t update = 1);
void acquire();
bool try_acquire() noexcept;
};std::counting_semaphore<LeastMaxValue> iz <semaphore> vzdržuje nenegativen števec. acquire() čaka na pozitivno vrednost in jo atomarno zmanjša; release(update) atomarno prišteje update in odblokira čakajoče. Učinek release močno predhodi uspešni pridobitvi, ki ta učinek opazi.
std::counting_semaphore::acquire blokira, dokler uspešno atomsko ne zmanjša pozitivnega števca. std::counting_semaphore::release atomsko poveča števec za update in odblokira čakajoče, s predpogojem 0 <= update <= max() - counter. std::counting_semaphore::max vrne največjo podprto vrednost števca, vsaj LeastMaxValue, ne trenutnega števila dovoljenj.
LeastMaxValue mora biti nenegativen. Konstruktor zahteva 0 <= desired && desired <= max(), release pa 0 <= update && update <= max() - counter; prekoračitev zmogljivosti krši predpogoj. Objekta ni mogoče kopirati, uničenje pa ne sme tekmovati z nitmi, ki ga še uporabljajo.
try_acquire() ne blokira, vendar lahko lažno vrne false tudi pri pozitivnem števcu. Časovne različice se lahko končajo po roku. Semafor prenaša dovoljenja; poljubnih podatkov sam ne varuje kot mutex, zato skupno stanje še vedno potrebuje pravilen sinhronizacijski protokol.
Primeri
#include <iostream>
#include <semaphore>
#include <thread>
int main() {
std::counting_semaphore<1> ready{0};
int value = 0;
std::jthread worker([&] {
ready.acquire();
value = 42;
});
ready.release();
worker.join();
std::cout << value << '\n';
}
Rezultat
42
std::counting_semaphore → 42