Optimistisches Sperren für die nebenläufige Lizenzaktivierung
Zwei Maschinen beanspruchen den letzten Platz in derselben Millisekunde. Ein naives Lesen-Zählen-Schreiben lässt beide herein und überverkauft die Lizenz. So macht optimistische Nebenläufigkeit aus der Platzbeanspruchung ein Compare-and-Swap, und so behandelt das SDK den 409.
Die meiste Zeit ist das Beanspruchen eines Platzes langweilig. Ein Client bittet den ausstellenden Dienst um einen Platz, der Dienst prüft, dass der Pool nicht voll ist, verzeichnet die Beanspruchung und antwortet mit Ja. Der interessante Fall ist der, der genau um 9:00 Uhr passiert, wenn eine Schicht beginnt: Zweihundert Maschinen wachen auf und bitten in denselben wenigen Millisekunden um einen Platz, und dem Pool bleibt ein Platz. Wer bekommt ihn?
Wenn du die Platzbeanspruchung auf die naheliegende Weise baust — die aktuelle Anzahl lesen, prüfen, dass sie unter dem Limit liegt, die erhöhte Anzahl schreiben — dann lesen unter dieser Welle beide Maschinen, die um den letzten Platz rennen, „24 von 25 belegt“, beide entscheiden, dass Platz ist, und beide schreiben „25“. Du hast 26 Plätze auf einer 25-Platz-Lizenz verkauft. Der Kunde ist nun ohne eigenes Verschulden nicht mehr konform, und du erfährst es erst, wenn der 26. Benutzer den Support anruft. Das ist das Problem des letzten Platzes, und es ist kein Keyright-spezifischer Fehler — es ist das klassische Lost-Update-Rennen, angewandt auf einen Lizenzpool.
In diesem Artikel geht es um den Mechanismus, der es unmöglich macht: optimistische Nebenläufigkeit. Die Platzbeanspruchung ist kein Lesen gefolgt von einem Schreiben. Sie ist ein einziger bedingter Schreibvorgang — ein Compare-and-Swap auf einem Versions-Token — der entweder sauber gewinnt oder sauber abgelehnt wird, ohne Zwischenzustand, in dem zwei Clients beide glauben, gewonnen zu haben.
Das Rennen, gezeichnet
Stell dir zwei Clients vor, A und B, beide mit einem gültigen Lizenzschlüssel, die beide im selben Augenblick den ausstellenden Dienst erreichen, während ein Platz frei ist.
Beide Clients lesen denselben Zustand: 24 von 25 belegten Plätzen, getragen zusammen mit einem Versions-Token — hier v=57. Dieses Token ist der ganze Trick. Es ist ein opaker Wert, den der ausstellende Dienst an den aktuellen Zustand des Platzpools anheftet, und er ändert sich jedes Mal, wenn sich der Pool ändert. Wenn ein Client seine Beanspruchung zurücksendet, schließt er die Version ein, die er gelesen hat, und der Dienst akzeptiert den Schreibvorgang nur, wenn die Version noch 57 ist. Der Schreibvorgang von Client A landet zuerst, die Anzahl wird 25, und die Version rückt auf 58 vor. Die Beanspruchung von Client B trifft einen Augenblick später ein und trägt v=57 — aber der Pool ist bereits bei v=58, also schlägt die Bedingung fehl und der Schreibvorgang wird abgelehnt, bevor er die Anzahl berühren kann. B bekam nie einen Platz; die Anzahl überstieg nie 25.
Was der Client sieht
Die wichtige Entwurfsentscheidung ist, dass die Ablehnung von B nicht dasselbe ist wie ein voller Pool. Es ist ein Nebenläufigkeitskonflikt — ein Signal, dass B ein Rennen verloren hat und erneut hinsehen sollte, weil der Zustand, auf dem es entschied, veraltet ist. Keyright gibt das als eine eigene ConcurrencyConflictException aus (HTTP 409 mit einem Konflikt-Problem-Type), getrennt von SeatsExhaustedException, und das SDK wiederholt sie für dich.
var client = KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-studio",
PublicKeyBase64 = config["Keyright:PublicKey"], // verify-only, not a secret
ServiceUrl = config["Keyright:ServiceUrl"], // your self-hosted instance
});
try
{
// AcquireSeatAsync retries a concurrency conflict internally,
// re-reading the version each time, with bounded jittered backoff.
SeatLease lease = await client.AcquireSeatAsync(userKey);
EnableLicensedFeatures(lease);
}
catch (SeatsExhaustedException)
{
// Definitive: the pool really is full after the race settled.
ShowAllSeatsInUse();
}
Beachte, was du nicht schreibst: keine Sperre, keine Transaktion, keine Wiederholungsschleife für den Konfliktfall. Das Compare-and-Swap lebt serverseitig und die Wiederholung steckt in AcquireSeatAsync. Der einzige Fehler, den du selbst behandelst, ist der echte — der volle Pool —, den du dem Benutzer zeigst und bei dem du geschlossen scheiterst.
Wenn du die HTTP-API direkt ansteuerst statt über das SDK, ist der Konflikt auf der Leitung sichtbar, und der Vertrag ist einfach: bei 409 conflict wiederholen, 409 seats-exhausted dem Benutzer zeigen.
POST /v1/seats/acquire HTTP/1.1
Host: license.internal.acme.example
Content-Type: application/json
{ "product": "acme-studio", "licenseKey": "ACME-...-9F2C", "machine": "b14c…" }
HTTP/1.1 409 Conflict
Content-Type: application/problem+json
{ "type": "https://keyright/problems/concurrency-conflict",
"title": "Seat state changed during the claim",
"status": 409, "retryable": true }
Der Hinweis retryable ist das einzige Feld, auf das sich deine eigene Wiederholungsrichtlinie verzweigen sollte. Ein concurrency-conflict ist wiederholbar; ein seats-exhausted ist es nicht. Sie gleich zu behandeln ist der übliche Fehler: Entweder wiederholst du einen vollen Pool nutzlos und hämmerst auf den Dienst ein, oder du gibst bei einem Konflikt auf und sagst einem rechtmäßigen Benutzer fälschlich, die Lizenz sei voll, obwohl die ganze Zeit ein Platz frei war.
Warum optimistisch, nicht pessimistisch
Die naheliegende Alternative ist eine pessimistische Sperre: eine exklusive Sperre über den Platzpool nehmen, das Lesen-Prüfen-Schreiben darin ausführen, freigeben. Das ist korrekt, aber es serialisiert jede Aktivierung eines Produkts durch ein einziges Tor. Die 9:00-Uhr-Welle, die diesen ganzen Entwurf motiviert hat, würde dann zweihundert Aktivierungen eine hinter der anderen in eine Warteschlange stellen, und der letzte Künstler, der startet, würde auf alle anderen warten. Du hättest einen Korrektheitsfehler gegen einen Latenzfehler eingetauscht.
Optimistische Nebenläufigkeit kehrt die Wette um. Sie nimmt an, dass Kollisionen selten sind — was sie über einen Platzpool hinweg auch sind — und lässt jede Beanspruchung parallel ganz ohne Sperre voranschreiten. Der einzige Preis wird von den Beanspruchungen gezahlt, die tatsächlich auf derselben Version kollidieren, und dieser Preis ist ein billiges erneutes Lesen und eine Wiederholung. Unter der Welle berühren die allermeisten Beanspruchungen unterschiedliche Platzanzahlen (weil die Gewinner die Version weiter vorrücken) und gehen beim ersten Versuch durch; nur die Handvoll, die um genau denselben letzten Platz streitet, wiederholt überhaupt. Du bekommst sperrfreien Durchsatz für den Normalfall und einen serialisierten, überverkaufssicheren Schreibvorgang für den umkämpften.
Die Garantie verdient es, klar ausgesprochen zu werden, denn sie ist der Grund, warum das ganze Schema sicher ist: keine Folge nebenläufiger Beanspruchungen kann die Anzahl über das Limit hinaus treiben. Jede Erhöhung ist bedingt auf die Version, aus der sie berechnet wurde, sodass zwei Erhöhungen niemals beide auf dieselbe Ausgangsanzahl angewendet werden können. Eine gewinnt und rückt die Version vor; die andere wird abgelehnt und muss von der neuen Anzahl von vorn beginnen — woraufhin sie korrekt sieht, dass der Pool voll ist, und eine SeatsExhaustedException erhält.
Das Wichtigste
- Die Platzbeanspruchung ist ein Compare-and-Swap auf einem Versions-Token, kein Lesen-dann-Schreiben — sodass zwei Clients, die um den letzten Platz rennen, niemals beide gewinnen können.
- Eine
ConcurrencyConflictException(409 conflict,retryable: true) bedeutet „erneut lesen und noch einmal versuchen“, und das SDK erledigt das für dich;SeatsExhaustedExceptionbedeutet „tatsächlich voll“, und du scheiterst geschlossen. - Verzweige deine eigene Wiederholungsrichtlinie auf den Hinweis
retryable: wiederhole niemals einen vollen Pool, wiederhole immer einen Konflikt. - Optimistische Nebenläufigkeit hält Aktivierungen parallel und zahlt nur dann einen Preis, wenn Beanspruchungen tatsächlich kollidieren, sodass sich eine Schichtwechsel-Welle nicht hinter einer einzigen Sperre serialisiert.
Korrektes Platzzählen bedeutet nicht, sorgfältig zu zählen. Es bedeutet, die Erhöhung atomar zu machen, sodass es kein Fenster gibt, in dem zwei Clients beide glauben können, der letzte Platz sei ihrer. Keyright tut das mit einem Versions-Token und einem bedingten Schreibvorgang und lässt deinem Client nichts zu tun übrig, als einen vollen Pool von einem verlorenen Rennen zu unterscheiden.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.