Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::counting_semaphore: limitar acessos simultâneos

std::counting_semaphore mantém um contador de permissões; acquire consome uma e release devolve permissões e pode desbloquear uma espera.

Versão: C++23

Sintaxe

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>, de <semaphore>, mantém um contador não negativo. acquire() espera que fique positivo e decrementa-o atomicamente; release(update) soma update atomicamente e desbloqueia esperas. O efeito de release acontece fortemente antes de uma aquisição bem-sucedida que o observe.

std::counting_semaphore::acquire bloqueia até conseguir decrementar atomicamente um contador positivo. std::counting_semaphore::release incrementa atomicamente o contador em update e desbloqueia esperas, com a pré-condição 0 <= update <= max() - counter. std::counting_semaphore::max devolve o maior valor de contador suportado, pelo menos LeastMaxValue, não o número atual de permissões.

LeastMaxValue tem de ser não negativo. O construtor exige 0 <= desired && desired <= max() e release exige 0 <= update && update <= max() - counter; exceder a capacidade viola uma pré-condição. O objeto não é copiável e a destruição não pode concorrer com threads que ainda o usam.

try_acquire() não bloqueia, mas pode devolver false de forma espúria mesmo com contador positivo. As variantes temporizadas podem terminar depois do prazo. Um semáforo transfere permissões; não protege sozinho dados arbitrários como um mutex, pelo que o estado partilhado requer um protocolo correto.

Exemplos

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

Resultado

42

std::counting_semaphore → 42

Fontes