Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::counting_semaphore: limitar accesos simultáneos

std::counting_semaphore mantiene un contador de permisos; acquire consume uno y release devuelve permisos y puede desbloquear una espera.

Versión: C++23

Sintaxis

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>, mantiene un contador no negativo. acquire() espera hasta que sea positivo y lo decrementa atómicamente; release(update) suma update atómicamente y desbloquea esperas. El efecto de release sucede fuertemente antes de una adquisición correcta que lo observa.

std::counting_semaphore::acquire bloquea hasta decrementar atómicamente con éxito un contador positivo. std::counting_semaphore::release incrementa atómicamente el contador en update y desbloquea esperas, con la precondición 0 <= update <= max() - counter. std::counting_semaphore::max devuelve el mayor valor de contador soportado, al menos LeastMaxValue, no el número actual de permisos.

LeastMaxValue debe ser no negativo. El constructor exige 0 <= desired && desired <= max() y release exige 0 <= update && update <= max() - counter; superar la capacidad incumple una precondición. El objeto no es copiable y su destrucción no puede competir con hilos que aún lo usan.

try_acquire() no bloquea, pero puede devolver espuriamente false aun con contador positivo. Las variantes temporizadas pueden terminar después del plazo. Un semáforo transfiere permisos; no protege por sí solo datos arbitrarios como un mutex, así que el estado compartido requiere un protocolo correcto.

Ejemplos

#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

Fuentes