WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::counting_semaphore: gleichzeitige Zugriffe begrenzen

std::counting_semaphore verwaltet eine Zahl von Erlaubnissen; acquire verbraucht eine, release gibt Erlaubnisse zurück und kann Wartende wecken.

Version: 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> aus <semaphore> verwaltet einen nichtnegativen Zähler. acquire() wartet auf einen positiven Wert und verringert ihn atomar; release(update) addiert update atomar und entsperrt Wartende. Ein Release-Effekt geschieht stark vor einem erfolgreichen Erwerb, der diesen Effekt beobachtet.

std::counting_semaphore::acquire blockiert, bis es einen positiven Zähler erfolgreich atomar verringert. std::counting_semaphore::release erhöht den Zähler atomar um update und entsperrt Wartende, mit der Vorbedingung 0 <= update <= max() - counter. std::counting_semaphore::max liefert den größten unterstützten Zählerwert, mindestens LeastMaxValue, nicht die aktuelle Erlaubniszahl.

LeastMaxValue muss nichtnegativ sein. Der Konstruktor verlangt 0 <= desired && desired <= max(), release verlangt 0 <= update && update <= max() - counter; ein Überschreiten der Kapazität verletzt eine Vorbedingung. Das Objekt ist nicht kopierbar und darf nicht zerstört werden, solange Threads es verwenden.

try_acquire() blockiert nicht, darf aber trotz positivem Zähler fälschlich false liefern. Zeitbegrenzte Varianten können nach ihrem Termin enden. Ein Semaphor überträgt Erlaubnisse; beliebige Daten schützt er nicht selbst wie ein Mutex, daher braucht gemeinsamer Zustand weiterhin ein korrektes Synchronisationsprotokoll.

Beispiele

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

Ergebnis

42

std::counting_semaphore → 42

Quellen