System.Threading.Channels en .NET 10, medido: la escritura devolvió true y el elemento ya no estaba

Cuando un productor va más rápido que su consumidor, hay que sacrificar algo. La cola que hay entre los dos puede crecer sin límite, el productor puede quedarse esperando o se pueden descartar elementos. System.Threading.Channels te obliga a elegir una de esas tres salidas, y eso está bien. Lo que me sorprendió es cómo informan dos de ellas: un canal acotado en modo de descarte responde true a la escritura de un elemento que acaba de tirar.

Medí un canal sin límite y los cuatro modos de uno acotado con la misma carga en .NET 10 y después rompí por la mitad una cadena de tres etapas (un pipeline) para ver quién se daba cuenta. Respuesta corta: nadie, salvo que cada etapa esté preparada para avisar a las demás.

Todos los ejemplos son aplicaciones de un solo archivo de .NET 10: guarda el bloque como .cs y ejecútalo con dotnet run -c Release <archivo>.cs, sin archivo de proyecto. Los números son de .NET 10.0.15 en una laptop de 8 núcleos. Todos están en dotnet-10-channels en GitHub, junto con las variantes del pipeline que el texto describe sin mostrarlas y un script que comprueba cada comportamiento.

Un brazo robótico coloca un cubo en una bandeja de tres huecos que ya está llena, bajo una marca verde de aprobado, mientras un cubo cae por el otro extremo a un contenedor

Un canal en un párrafo

Un canal es una cola segura para usar desde varios hilos, con dos extremos: un ChannelWriter<T> donde escriben los productores y un ChannelReader<T> de donde leen los consumidores. Los dos son asíncronos. Un lector que encuentra el canal vacío espera sin ocupar un hilo, y lo mismo hace un escritor que lo encuentra lleno. Channel.CreateUnbounded<T>() no se llena nunca. Channel.CreateBounded<T>(capacidad) sí, y su FullMode decide qué pasa entonces. Cuando el productor termina, llama a Writer.Complete(), y ReadAllAsync() acaba cuando el canal está marcado como completo y ya no le quedan elementos. Viene con .NET desde .NET Core 3.0, así que no hay ningún paquete que instalar.

Cinco escrituras en un canal con capacidad para tres

La forma más rápida de ver los cuatro modos es escribir cinco elementos en un canal de tres y leer lo que queda. itemDropped es un callback opcional, añadido en .NET 6, al que el canal llama con cada elemento que descarta:

using System.Threading.Channels; // Cinco escrituras en un canal con capacidad para tres, una vez por cada modo. foreach (BoundedChannelFullMode mode in Enum.GetValues<BoundedChannelFullMode>()) { List<int> dropped = []; Channel<int> channel = Channel.CreateBounded<int>( new BoundedChannelOptions(capacity: 3) { FullMode = mode }, itemDropped: dropped.Add); List<bool> accepted = []; for (int item = 1; item <= 5; item++) accepted.Add(channel.Writer.TryWrite(item)); channel.Writer.Complete(); List<int> read = []; await foreach (int item in channel.Reader.ReadAllAsync()) read.Add(item); Console.WriteLine($"{mode,-10} TryWrite: {string.Join(" ", accepted),-26} read: [{string.Join(", ", read)}] itemDropped: [{string.Join(", ", dropped)}]"); } 
Wait TryWrite: True True True False False read: [1, 2, 3] itemDropped: [] DropNewest TryWrite: True True True True True read: [1, 2, 5] itemDropped: [3, 4] DropOldest TryWrite: True True True True True read: [3, 4, 5] itemDropped: [1, 2] DropWrite TryWrite: True True True True True read: [1, 2, 3] itemDropped: [4, 5] 

En esas cuatro líneas conviene fijarse en tres cosas.

En los tres modos de descarte, todas las escrituras devolvieron True. En cada uno faltan dos de los cinco elementos, y al escritor se le dijo que todo había ido bien. WriteAsync se comporta igual: en la prueba de carga de más abajo, las 20.000 llamadas terminaron con normalidad, incluidas las miles cuyo elemento se descartó. El callback itemDropped es el único sitio donde el canal lo avisa, y es fácil pasarlo por alto porque es un parámetro opcional de un método de fábrica. Además se ejecuta en el hilo del escritor, durante la escritura y fuera del lock del canal, así que con varios productores puede ejecutarse en varios hilos a la vez. Para contar, usa algo como el Interlocked.Increment de la prueba de carga de más abajo; la List de este ejemplo solo es segura porque un único hilo hace todas las escrituras. Si te suena, es la misma lección que channel.publish cuando devuelve true en RabbitMQ de los fundamentos a producción, Parte 2: construir un servicio escalable.

DropNewest no descarta el elemento que estás escribiendo. Descarta el más nuevo de los que ya están en el canal para hacerle sitio: escribir el 4 expulsó al 3, y escribir el 5 expulsó al 4. El canal conserva los más antiguos y el último de todos. El modo que rechaza el elemento que llega es DropWrite.

En modo Wait, TryWrite no espera. Devuelve False cuando el canal está lleno; solo WriteAsync espera a que haya sitio. Un productor que llama a TryWrite e ignora el resultado pierde elementos justo en el modo cuyo nombre promete que eso no pasa.

La misma elección, bajo carga

Cinco elementos enseñan qué hace cada modo, pero no cuánto cuesta. Para eso simulé el gateway de sensores de un camión refrigerado: 20.000 mediciones de temperatura que se reciben en 20 µs cada una y se guardan en 200 µs, así que el productor va diez veces más rápido que el consumidor. La capacidad es de 1.000. Los dos costos son una espera activa, que sustituye a un trabajo real de costo estable y conocido, para que lo único que cambie de una fila a otra sea el canal:

using System.Diagnostics; using System.Threading.Channels; const int Total = 20_000; const int Capacity = 1_000; TimeSpan receiveCost = TimeSpan.FromMicroseconds(20); // leer un mensaje del socket TimeSpan storeCost = TimeSpan.FromMicroseconds(200); // insertarlo en la base de datos Console.WriteLine($"{Total:N0} readings, received in {receiveCost.TotalMicroseconds} µs and stored in {storeCost.TotalMicroseconds} µs each, capacity {Capacity:N0}"); Console.WriteLine($"{"mode",-10} {"producer",8} {"total",7} {"stored",8} {"dropped",8} {"median wait",12} {"max wait",9}"); await MeasureAsync("Unbounded", Channel.CreateUnbounded<Reading>(new UnboundedChannelOptions { SingleReader = true }), dropped: () => 0); foreach (BoundedChannelFullMode mode in Enum.GetValues<BoundedChannelFullMode>()) { long dropped = 0; Channel<Reading> channel = Channel.CreateBounded<Reading>( new BoundedChannelOptions(Capacity) { FullMode = mode }, itemDropped: _ => Interlocked.Increment(ref dropped)); await MeasureAsync(mode.ToString(), channel, dropped: () => Interlocked.Read(ref dropped)); } async Task MeasureAsync(string mode, Channel<Reading> channel, Func<long> dropped) { int stored = 0; TimeSpan[] waits = new TimeSpan[Total]; // desde que llega cada medición guardada hasta que se guarda Stopwatch clock = Stopwatch.StartNew(); Task consumer = Task.Run(async () => { await foreach (Reading reading in channel.Reader.ReadAllAsync()) { Work(storeCost); waits[stored++] = Stopwatch.GetElapsedTime(reading.ReceivedAt); } }); for (long sequence = 0; sequence < Total; sequence++) { Work(receiveCost); await channel.Writer.WriteAsync(new Reading(sequence, "truck-17", 4.2, Stopwatch.GetTimestamp())); } TimeSpan producer = clock.Elapsed; channel.Writer.Complete(); await consumer; // a partir de aquí, los contadores que escribió el consumidor se pueden leer sin riesgo TimeSpan total = clock.Elapsed; Array.Sort(waits, 0, stored); Console.WriteLine($"{mode,-10} {producer.TotalSeconds,7:F2}s {total.TotalSeconds,6:F2}s {stored,8:N0} {dropped(),8:N0} {waits[stored / 2].TotalMilliseconds,9:N1} ms {waits[stored - 1].TotalMilliseconds,6:N0} ms"); } // Espera activa durante un tiempo fijo: sustituye a un trabajo real de costo estable y conocido. static void Work(TimeSpan duration) { long until = Stopwatch.GetTimestamp() + (long)(duration.TotalSeconds * Stopwatch.Frequency); while (Stopwatch.GetTimestamp() < until) { } } record Reading(long Sequence, string SensorId, double Celsius, long ReceivedAt); 

SingleReader = true le dice al canal sin límite que nunca habrá más de una lectura en curso a la vez, algo que garantiza un único bucle await foreach aunque sus await continúen en hilos distintos. Con eso, CreateUnbounded elige una implementación más rápida, y como nada comprueba que sea cierto, actívalo solo cuando lo sea. El canal acotado no tiene esa variante en .NET 10: CreateBounded ignora tanto SingleReader como SingleWriter, así que no los puse.

20,000 readings, received in 20 µs and stored in 200 µs each, capacity 1,000 mode producer total stored dropped median wait max wait Unbounded 0.42s 4.04s 20,000 0 1,813.4 ms 3,621 ms Wait 3.86s 4.06s 20,000 0 203.3 ms 204 ms DropNewest 0.41s 0.61s 3,018 16,982 200.4 ms 202 ms DropOldest 0.40s 0.60s 3,012 16,988 20.4 ms 201 ms DropWrite 0.40s 0.60s 3,012 16,988 200.6 ms 201 ms 

Esa es una de tres corridas. Otra coincidió con ella en todas las filas, con diferencias de menos de 0,02 segundos y 25 mediciones guardadas. En la tercera, algo más que corría en la laptop frenó al consumidor durante los modos de descarte: guardaron entre 1.673 y 2.720 mediciones en lugar de unas 3.000, y sus medianas de espera subieron, aunque la de DropOldest siguió siendo la más baja (53 ms frente a 236 y 508). Los tiempos cambian de una corrida a otra; lo que cada modo hace con las mediciones, no.

  • El canal sin límite (Unbounded) no perdió nada ni frenó al productor. Lo que hizo fue pasar el problema a la memoria. Cuando la ráfaga terminó, a los 0,42 segundos, el consumidor había guardado menos de 2.500 de las 20.000 mediciones, y el resto se quedó en la cola: una mediana de 1,8 segundos de espera cada una. Si la ráfaga no termina, esa cola crece hasta que el proceso se queda sin memoria.
  • Wait no perdió nada e hizo pagar al productor. Tardó unos 4 segundos en lugar de 0,4, que es el ritmo del consumidor. Cada medición esperó una mediana de 203 ms: la capacidad por lo que cuesta guardar una medición, 1.000 × 200 µs. Esa es la latencia que eliges cuando eliges la capacidad.
  • Los tres modos de descarte mantuvieron al productor a toda velocidad y tiraron el 85% de las mediciones. Cada uno guardó unas 3.000: las 2.000 y pico que el consumidor alcanzó a guardar en 0,4 segundos a 200 µs cada una, más las 1.000 que quedaban en el buffer.
  • Solo DropOldest mantuvo al consumidor con datos recientes. Su mediana de espera fue de 20 ms, frente a unos 200 ms de los otros dos. Su buffer siempre contiene las últimas 1.000 mediciones en llegar, y llega una cada 20 µs, así que la más antigua de ellas, que es la siguiente que toma el consumidor, llegó hace 1.000 × 20 µs = 20 ms. En DropNewest y DropWrite, una medición entra solo cuando el consumidor libera un hueco, y después espera a que se guarden las 1.000 que tiene delante: 1.000 × 200 µs, 200 ms. El máximo ronda los 200 ms en los tres porque mide cómo se vacía el buffer cuando el productor ya terminó.

Así que el modo correcto depende de los datos, no de la velocidad:

  • Wait para todo lo que no puedes perder: pedidos, pagos, mensajes que vas a confirmar a un broker. El productor va más lento, y lo que lo alimenta también tendrá que ir más lento.
  • DropOldest cuando el valor más reciente reemplaza a los anteriores, como una temperatura o una posición, siempre que el canal lleve una sola fuente. Un canal no tiene claves: con toda una flota en el mismo canal, la única medición de un camión que apenas envía datos suele ser la más antigua, y es la que se descarta. Con muchas fuentes, usa un canal por fuente o un diccionario con el último valor de cada una.
  • DropWrite para datos en los que cualquier muestra sirve y perder algunos no tiene consecuencias, como los eventos de analítica. Conserva lo que ya está en cola y rechaza lo nuevo. DropNewest se comportó casi igual bajo carga; la única diferencia es qué elemento sale, el que llega o el último que estaba en cola.
  • En cualquier modo de descarte, cuenta itemDropped y publícalo como métrica. Una medición descartada que nadie contó es indistinguible de una que nunca se envió.

Cuatro bandejas con tres cubos numerados, cada una recibiendo un cubo nuevo: la primera cerrada con una barrera y un reloj de arena, otra que deja caer su cubo más antiguo por el otro extremo y otra que rechaza el cubo que llega

Un pipeline en el que una etapa lanza una excepción

Donde más rinden los canales es conectando etapas: cada etapa lee de un canal y escribe en el siguiente. Este es el gateway convertido en tres etapas, receive → parse → store, con un canal acotado entre cada par. En la medición 5.000, la sonda del camión 17 se desconecta y el gateway envía N/A en lugar de una temperatura:

using System.Globalization; using System.Threading.Channels; // receive → parse → store, con un canal acotado entre cada par de etapas. Channel<string> lines = Channel.CreateBounded<string>(100); Channel<Reading> readings = Channel.CreateBounded<Reading>(100); int received = 0, parsed = 0, stored = 0; Task receive = Task.Run(async () => { for (int sequence = 0; sequence < 10_000; sequence++) { // La sonda del camión 17 se desconecta una vez y el gateway envía N/A en lugar de una temperatura. string line = sequence == 5_000 ? $"{sequence};truck-17;N/A" : $"{sequence};truck-17;4.2"; await lines.Writer.WriteAsync(line); Interlocked.Increment(ref received); } lines.Writer.Complete(); }); Task parse = Task.Run(async () => { await foreach (string line in lines.Reader.ReadAllAsync()) { string[] fields = line.Split(';'); Reading reading = new(long.Parse(fields[0], CultureInfo.InvariantCulture), fields[1], double.Parse(fields[2], NumberStyles.Float, CultureInfo.InvariantCulture)); await readings.Writer.WriteAsync(reading); Interlocked.Increment(ref parsed); } readings.Writer.Complete(); }); Task store = Task.Run(async () => { await foreach (Reading reading in readings.Reader.ReadAllAsync()) Interlocked.Increment(ref stored); }); Task pipeline = Task.WhenAll(receive, parse, store); if (await Task.WhenAny(pipeline, Task.Delay(TimeSpan.FromSeconds(10))) != pipeline) Console.WriteLine($"Still running after 10 s. receive: {receive.Status}, parse: {parse.Status}, store: {store.Status}"); Console.WriteLine($"received {Volatile.Read(ref received):N0}, parsed {Volatile.Read(ref parsed):N0}, stored {Volatile.Read(ref stored):N0}, waiting in lines: {lines.Reader.Count}"); record Reading(long Sequence, string SensorId, double Celsius); 
Still running after 10 s. receive: WaitingForActivation, parse: Faulted, store: WaitingForActivation received 5,101, parsed 5,000, stored 5,000, waiting in lines: 100 

parse lanzó una FormatException con la medición 5.000, y su tarea está en Faulted. Nadie más se enteró:

  • receive está bloqueada. Llenó lines con las 100 líneas siguientes y espera en WriteAsync un hueco que nunca se va a liberar, porque ya nadie lee lines.
  • store espera mediciones que nunca van a llegar. readings nunca se marcó como completo, así que su ReadAllAsync no puede distinguir entre "todavía no hay datos" y "ya no habrá más".
  • Task.WhenAll no puede hacer nada. Espera a las tres tareas, dos de ellas no terminan nunca, y la excepción que relanzaría se queda dentro de una tarea fallida.

Ni un cierre, ni una línea de log, ni consumo de CPU: como fallo, es de lo más tranquilo. Sin el temporizador de 10 segundos del final, el proceso se quedaría así hasta que alguien lo reiniciara, y en un servicio parecería un consumidor que se detuvo sin motivo.

El consejo habitual es completar el writer en un finally, para que la etapa siguiente nunca se quede esperando. También lo medí, con el bucle de cada etapa dentro de try { … } finally { writer.Complete(); } y nada más cambiado:

Still running after 10 s. receive: WaitingForActivation, parse: Faulted, store: RanToCompletion received 5,101, parsed 5,000, stored 5,000, waiting in lines: 100 

store termina ahora en RanToCompletion, es decir, con éxito, después de guardar 5.000 de las 10.000 mediciones, como si el flujo hubiera acabado ahí. Y receive sigue colgada, porque un finally que completa el canal posterior a una etapa no hace nada por la etapa anterior. El bloqueo sigue ahí, y además la etapa siguiente da por buena la mitad de los datos.

Una etapa que falla tiene que avisar en las dos direcciones:

  • A la etapa siguiente, completando su salida con la excepción: writer.Complete(exception). El ReadAllAsync de la siguiente lee lo que queda en el canal y después lanza la excepción.
  • A la etapa anterior, cancelándola. Lo que esa etapa esté esperando, un canal lleno, uno vacío o su propia fuente de datos, lanza entonces OperationCanceledException en lugar de esperar para siempre, y esa etapa, al detenerse, cancela a su vez la anterior.

El pipeline, corregido

Todas las etapas de abajo pasan por una función auxiliar que hace las dos cosas. Cambiaron dos cosas más. Una línea mal formada ahora se cuenta y se salta, porque un dato malo no es motivo para detener un pipeline. Y para comprobar qué pasa cuando algo falla de verdad, store lanza una excepción al llegar a la medición 7.000, como cuando la conexión a la base de datos acaba cayéndose:

using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Threading.Channels; // Un token por etapa, para todo lo que esa etapa espera. Solo lo cancela la etapa siguiente, // cuando falla, así que la parada recorre el pipeline hasta la primera etapa, y las etapas // posteriores a un fallo nunca se cancelan: leen lo que queda y después reciben la excepción. // En una aplicación, enlaza los tres también con el token de apagado. using CancellationTokenSource stopReceive = new(), stopParse = new(), stopStore = new(); Channel<string> lines = Channel.CreateBounded<string>(100); Channel<Reading> readings = Channel.CreateBounded<Reading>(100); int received = 0, rejected = 0, parsed = 0, stored = 0; Task receive = RunStageAsync(stopReceive, stopPrevious: null, complete: error => lines.Writer.TryComplete(error), body: async cancellation => { for (int sequence = 0; sequence < 10_000; sequence++) { string line = sequence == 5_000 ? $"{sequence};truck-17;N/A" : $"{sequence};truck-17;4.2"; await lines.Writer.WriteAsync(line, cancellation); Interlocked.Increment(ref received); } }); Task parse = RunStageAsync(stopParse, stopPrevious: stopReceive, complete: error => readings.Writer.TryComplete(error), body: async cancellation => { await foreach (string line in lines.Reader.ReadAllAsync(cancellation)) { // Una línea mal formada es un dato malo, no un pipeline roto: se cuenta y se sigue. if (!TryParse(line, out Reading? reading)) { Interlocked.Increment(ref rejected); continue; } await readings.Writer.WriteAsync(reading, cancellationSource:https://dev.to/jgomezdev/systemthreadingchannels-en-net-10-medido-la-escritura-devolvio-true-y-el-elemento-ya-no-estaba-9am

Related posts