Bloqueo optimista para la activación concurrente de licencias
Dos máquinas reclaman el asiento final en el mismo milisegundo. Un ingenuo leer-contar-escribir deja entrar a las dos y sobrevende la licencia. Así es como la concurrencia optimista convierte el reclamo de asiento en un compare-and-swap, y cómo el SDK maneja el 409.
La mayor parte del tiempo, reclamar un asiento es aburrido. Un cliente pide un asiento al servicio emisor, el servicio comprueba que el grupo no está lleno, registra el reclamo y responde que sí. El caso interesante es el que ocurre exactamente a las 9:00 de la mañana cuando empieza un turno: doscientas máquinas despiertan y piden un asiento en los mismos pocos milisegundos, y al grupo le queda un asiento. ¿Quién lo consigue?
Si construyes el reclamo de asiento de la forma obvia —leer el conteo actual, comprobar que está por debajo del límite, escribir el conteo incrementado— entonces, bajo esa ráfaga, ambas máquinas que corren por el último asiento leen «24 de 25 usados», ambas deciden que hay sitio y ambas escriben «25». Has vendido 26 asientos en una licencia de 25. El cliente queda ahora fuera de cumplimiento sin culpa alguna, y solo te enteras cuando el usuario número 26 llama a soporte. Este es el problema del último asiento, y no es un error específico de Keyright: es la clásica carrera de actualización perdida, aplicada a un grupo de licencias.
Este artículo trata del mecanismo que lo hace imposible: la concurrencia optimista. El reclamo de asiento no es una lectura seguida de una escritura. Es una única escritura condicional —un compare-and-swap sobre un token de versión— que o bien gana limpiamente o bien es rechazada limpiamente, sin estado intermedio en el que dos clientes crean ambos que ganaron.
La carrera, dibujada
Imagina dos clientes, A y B, ambos con una clave de licencia válida, ambos alcanzando el servicio emisor en el mismo instante con un asiento libre.
Ambos clientes leen el mismo estado: 24 asientos usados de 25, acarreado junto con un token de versión —aquí, v=57. Ese token es todo el truco. Es un valor opaco que el servicio emisor adjunta al estado actual del grupo de asientos, y cambia cada vez que el grupo cambia. Cuando un cliente devuelve su reclamo, incluye la versión que leyó, y el servicio acepta la escritura solo si la versión sigue siendo 57. La escritura del Cliente A aterriza primero, el conteo pasa a 25 y la versión avanza a 58. El reclamo del Cliente B llega un instante después portando v=57 —pero el grupo ya está en v=58, así que la condición falla y la escritura se rechaza antes de que pueda tocar el conteo. B nunca obtuvo un asiento; el conteo nunca pasó de 25.
Lo que ve el cliente
La decisión de diseño importante es que el rechazo de B no es lo mismo que el grupo estar lleno. Es un conflicto de concurrencia —una señal de que B perdió una carrera y debería mirar de nuevo, porque el estado sobre el que decidió es obsoleto. Keyright lo expone como una ConcurrencyConflictException distinta (HTTP 409 con un problem-type de conflicto), separada de SeatsExhaustedException, y el SDK lo reintenta por ti.
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();
}
Observa lo que no escribes: no hay bloqueo, ni transacción, ni bucle de reintento para el caso del conflicto. El compare-and-swap vive en el servidor y el reintento está dentro de AcquireSeatAsync. El único fallo que gestionas tú mismo es el genuino —que el grupo esté lleno— que muestras al usuario y sobre el que fallas de forma cerrada.
Si manejas la API HTTP directamente en lugar de a través del SDK, el conflicto es visible en el cable, y el contrato es simple: reintentar ante 409 conflict, mostrar 409 seats-exhausted al usuario.
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 }
La pista retryable es el único campo sobre el que tu propia política de reintento debería ramificar. Un concurrency-conflict es reintentable; un seats-exhausted no lo es. Tratarlos de la misma manera es el error habitual: o reintentas un grupo lleno inútilmente y machacas el servicio, o te rindes ante un conflicto y le dices por error a un usuario legítimo que la licencia está llena cuando había un asiento libre todo el tiempo.
Por qué optimista, no pesimista
La alternativa obvia es un bloqueo pesimista: tomar un bloqueo exclusivo sobre el grupo de asientos, hacer el leer-comprobar-escribir dentro de él, liberar. Eso es correcto, pero serializa cada activación de un producto a través de una única puerta. La ráfaga de las 9:00 que motivó todo este diseño encolaría entonces doscientas activaciones una detrás de otra, y el último artista en empezar esperaría por todos los demás. Habrías cambiado un error de corrección por un error de latencia.
La concurrencia optimista invierte la apuesta. Asume que las colisiones son raras —lo que, a lo largo de un grupo de asientos, lo son— y deja que cada reclamo avance en paralelo sin ningún bloqueo. El único coste lo pagan los reclamos que realmente colisionan sobre la misma versión, y ese coste es una relectura y un reintento baratos. Bajo la ráfaga, la gran mayoría de los reclamos tocan conteos de asientos distintos (porque los ganadores siguen avanzando la versión) y pasan sin problemas en el primer intento; solo el puñado que contiende por exactamente el mismo asiento final llega a reintentar. Obtienes rendimiento sin bloqueo para el caso común y una escritura serializada, a prueba de sobreventa, para el disputado.
La garantía merece enunciarse con claridad, porque es la razón por la que todo el esquema es seguro: ninguna secuencia de reclamos concurrentes puede empujar el conteo más allá del límite. Cada incremento está condicionado a la versión desde la que se calculó, de modo que dos incrementos nunca pueden aplicarse ambos al mismo conteo de partida. Uno gana y avanza la versión; el otro es rechazado y debe empezar de nuevo desde el nuevo conteo —momento en el que verá correctamente que el grupo está lleno y obtendrá una SeatsExhaustedException.
Conclusiones
- El reclamo de asiento es un compare-and-swap sobre un token de versión, no un leer-luego-escribir, de modo que dos clientes corriendo por el último asiento nunca pueden ganar ambos.
- Una
ConcurrencyConflictException(409 conflict,retryable: true) significa «vuelve a leer e inténtalo de nuevo», y el SDK lo gestiona por ti;SeatsExhaustedExceptionsignifica «genuinamente lleno», y fallas de forma cerrada. - Ramifica tu propia política de reintento sobre la pista
retryable: nunca reintentes un grupo lleno, siempre reintenta un conflicto. - La concurrencia optimista mantiene las activaciones en paralelo y solo paga un coste cuando los reclamos realmente colisionan, de modo que una ráfaga de cambio de turno no se serializa detrás de un único bloqueo.
El conteo correcto de asientos no consiste en contar con cuidado. Consiste en hacer atómico el incremento, de modo que no haya ventana en la que dos clientes puedan creer ambos que el último asiento es suyo. Keyright lo hace con un token de versión y una escritura condicional, y deja a tu cliente sin nada que hacer salvo distinguir un grupo lleno de una carrera perdida.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.