Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::counting_semaphore: limitare gli accessi simultanei

std::counting_semaphore mantiene un conteggio di permessi; acquire ne consuma uno e release li restituisce potendo sbloccare chi attende.

Versione: C++23

Sintassi

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> di <semaphore> mantiene un contatore non negativo. acquire() attende che sia positivo e lo decrementa atomicamente; release(update) aggiunge atomicamente update e sblocca chi attende. L’effetto di release precede fortemente un’acquisizione riuscita che osserva tale effetto.

std::counting_semaphore::acquire blocca finché riesce a decrementare atomicamente un contatore positivo. std::counting_semaphore::release incrementa atomicamente il contatore di update e sblocca chi attende, con precondizione 0 <= update <= max() - counter. std::counting_semaphore::max restituisce il massimo valore di contatore supportato, almeno LeastMaxValue, non il numero corrente di permessi.

LeastMaxValue deve essere non negativo. Il costruttore richiede 0 <= desired && desired <= max() e release richiede 0 <= update && update <= max() - counter; superare la capacità viola una precondizione. L’oggetto non è copiabile e la distruzione non deve concorrere con thread che lo usano.

try_acquire() non blocca, ma può restituire spuriosamente false anche con contatore positivo. Le varianti temporizzate possono terminare dopo la scadenza. Un semaforo trasferisce permessi; non protegge da solo dati arbitrari come un mutex, quindi lo stato condiviso richiede un protocollo corretto.

Esempi

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

Risultato

42

std::counting_semaphore → 42

Fonti