KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::counting_semaphore: gelijktijdige toegang begrenzen

std::counting_semaphore beheert een aantal vergunningen; acquire verbruikt er één en release geeft vergunningen terug en kan een wachtende thread vrijgeven.

Versie: C++23

Syntax

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> uit <semaphore> beheert een niet-negatieve teller. acquire() wacht tot deze positief is en verlaagt hem atomair; release(update) telt update atomair op en deblokkeert wachtenden. Een release-effect happens-before in sterke zin een geslaagde overname die dat effect waarneemt.

std::counting_semaphore::acquire blokkeert tot het een positieve teller met succes atomair verlaagt. std::counting_semaphore::release verhoogt de teller atomair met update en deblokkeert wachtenden, met voorwaarde 0 <= update <= max() - counter. std::counting_semaphore::max retourneert de grootste ondersteunde tellerwaarde, minstens LeastMaxValue, niet het huidige aantal permits.

LeastMaxValue moet niet-negatief zijn. De constructor vereist 0 <= desired && desired <= max() en release vereist 0 <= update && update <= max() - counter; capaciteit overschrijden schendt een preconditie. Het object is niet kopieerbaar en vernietiging mag niet concurreren met threads die het nog gebruiken.

try_acquire() blokkeert niet, maar mag ook bij een positieve teller spontaan false teruggeven. Getimede varianten kunnen na hun deadline eindigen. Een semafoor draagt vergunningen over; willekeurige gegevens worden niet vanzelf als door een mutex beschermd, dus gedeelde toestand vereist een correct protocol.

Voorbeelden

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

Resultaat

42

std::counting_semaphore → 42

Bronnen