Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::counting_semaphore : limiter les accès simultanés

std::counting_semaphore maintient un nombre de permis ; acquire en consomme un et release en restitue tout en pouvant débloquer un thread.

Version : C++23

Syntaxe

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> maintient un compteur non négatif. acquire() attend qu’il soit positif puis le décrémente atomiquement ; release(update) ajoute atomiquement update et débloque des attentes. L’effet de release précède fortement une acquisition réussie qui observe cet effet.

std::counting_semaphore::acquire bloque jusqu’à pouvoir décrémenter atomiquement un compteur positif. std::counting_semaphore::release l’incrémente atomiquement de update et débloque des attentes, avec la précondition 0 <= update <= max() - counter. std::counting_semaphore::max renvoie la plus grande valeur de compteur prise en charge, au moins LeastMaxValue, et non le nombre courant de permis.

LeastMaxValue doit être non négatif. Le constructeur exige 0 <= desired && desired <= max() et release exige 0 <= update && update <= max() - counter ; dépasser la capacité viole une précondition. L’objet n’est pas copiable et sa destruction ne doit pas concurrencer des threads qui l’utilisent.

try_acquire() ne bloque pas, mais peut rendre false de manière intempestive même avec un compteur positif. Les variantes temporisées peuvent finir après leur échéance. Un sémaphore transmet des permis ; il ne protège pas à lui seul des données arbitraires comme un mutex, d’où la nécessité d’un protocole correct.

Exemples

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

Résultat

42

std::counting_semaphore → 42

Sources