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 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. -
Waitno 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
DropOldestmantuvo 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. EnDropNewestyDropWrite, 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:
-
Waitpara 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. -
DropOldestcuando 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. -
DropWritepara 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.DropNewestse 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
itemDroppedy publícalo como métrica. Una medición descartada que nadie contó es indistinguible de una que nunca se envió.
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ó:
-
receiveestá bloqueada. Llenólinescon las 100 líneas siguientes y espera enWriteAsyncun hueco que nunca se va a liberar, porque ya nadie leelines. -
storeespera mediciones que nunca van a llegar.readingsnunca se marcó como completo, así que suReadAllAsyncno puede distinguir entre "todavía no hay datos" y "ya no habrá más". -
Task.WhenAllno 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). ElReadAllAsyncde 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
OperationCanceledExceptionen 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, cancellation);
Interlocked.Increment(ref parsed);
}
});
Task store = RunStageAsync(stopStore, stopPrevious: stopParse, complete: null, body: async cancellation =>
{
await foreach (Reading reading in readings.Reader.ReadAllAsync(cancellation))
{
// El fallo que nadie previó.
if (reading.Sequence == 7_000) throw new IOException("Database connection lost.");
Interlocked.Increment(ref stored);
}
});
try
{
await Task.WhenAll(receive, parse, store);
Console.WriteLine("Pipeline finished.");
}
catch (Exception ex)
{
Console.WriteLine($"Pipeline stopped: {ex.GetType().Name}: {ex.Message}");
}
Console.WriteLine($"receive: {receive.Status}, parse: {parse.Status}, store: {store.Status}");
Console.WriteLine($"received {received:N0}, rejected {rejected}, parsed {parsed:N0}, stored {stored:N0}");
// Ejecuta una etapa en el thread pool. Al terminar, completa el canal de salida de la etapa,
// con la excepción si falló, y un fallo cancela además la etapa anterior.
static async Task RunStageAsync(CancellationTokenSource stop, CancellationTokenSource? stopPrevious,
Action<Exception?>? complete, Func<CancellationToken, Task> body)
{
try
{
await Task.Run(() => body(stop.Token));
complete?.Invoke(null);
}
catch (OperationCanceledException ex) when (!stop.IsCancellationRequested)
{
// Cancelada por algo ajeno a este pipeline, como un timeout de HTTP. Eso es un fallo:
// envuelto, la tarea termina en Faulted y no se puede confundir con una parada.
StageFailedException failure = new(ex);
await FailAsync(failure);
throw failure;
}
catch (Exception ex)
{
await FailAsync(ex);
throw;
}
async Task FailAsync(Exception failure)
{
complete?.Invoke(failure); // la etapa siguiente lee lo que queda y después recibe el fallo
if (stopPrevious is not null)
await stopPrevious.CancelAsync(); // la etapa anterior se detiene, esté esperando lo que esté esperando
}
}
static bool TryParse(string line, [NotNullWhen(true)] out Reading? reading)
{
string[] fields = line.Split(';');
// NumberStyles.Float y no el estilo por defecto, que también acepta separador de miles y
// leería "4,2" como 42. IsFinite rechaza "NaN" e "Infinity".
if (fields.Length == 3
&& long.TryParse(fields[0], CultureInfo.InvariantCulture, out long sequence)
&& double.TryParse(fields[2], NumberStyles.Float, CultureInfo.InvariantCulture, out double celsius)
&& double.IsFinite(celsius))
{
reading = new Reading(sequence, fields[1], celsius);
return true;
}
reading = null;
return false;
}
// Sustituye a una OperationCanceledException que el pipeline no provocó, para que la tarea de
// la etapa termine en Faulted y no en Canceled.
sealed class StageFailedException(Exception inner) : Exception(inner.Message, inner);
record Reading(long Sequence, string SensorId, double Celsius);
Pipeline stopped: IOException: Database connection lost.
receive: Canceled, parse: Canceled, store: Faulted
received 7,202, rejected 1, parsed 7,100, stored 6,999
La línea con N/A se rechazó y el pipeline siguió. Cuando se cayó la "conexión" a la base de datos, las tres etapas se detuvieron y Task.WhenAll relanzó la IOException en lugar de quedarse colgado. Hay algunos detalles de la función auxiliar que es fácil pasar por alto:
-
Cada etapa tiene su propio token y lo usa para todo lo que espera: sus lecturas, sus escrituras y, en un servicio real, su propia E/S. Solo la cancela la etapa siguiente. Cuando falló
store, cancelóstopParse;parselanzó la excepción esperara lo que esperara, y al salir cancelóstopReceive, y así hasta el principio. -
Las etapas posteriores a un fallo nunca se cancelan. Leen lo que queda en su canal, y después
ReadAllAsynclanza la excepción original. -
Una
OperationCanceledExceptionque el pipeline no provocó es un fallo. Un timeout de HTTP dentro de una etapa lanza una, y sin más la tarea terminaría enCanceled, así que quien trateOperationCanceledExceptioncomo un apagado normal se tragaría una caída. El filtrowhenla envuelve en unaStageFailedException. -
Una etapa que detuvo el propio pipeline termina en
Canceled, no enFaulted, así que no añade nada a lo que informaTask.WhenAll, y la excepción que recibes es la causa. -
storepasacomplete: nullporque es la última etapa y no tiene canal de salida. YTask.Runarranca cada etapa en el thread pool, el grupo de hilos que .NET reutiliza para el trabajo asíncrono, así que las tres corren en paralelo desde el principio, en lugar de que la primera se ejecute en el hilo de quien la llama hasta su primera espera real.
Llegar hasta aquí me costó tres intentos. Mi primera versión cancelaba un único token compartido ante cualquier fallo, así que también se cancelaban las etapas posteriores al fallo: con un store lento, terminaba en Canceled antes de ver la excepción real, porque WaitToReadAsync comprueba el token antes de mirar el canal. La segunda pasaba cada token solo a las escrituras, y una etapa que esperaba datos nunca se enteraba del fallo. Con una fuente que enviaba 20 líneas y luego se quedaba en silencio, y store fallando en la décima, la segunda versión seguía corriendo a los 10 segundos; esta se detuvo en 36 ms.
En esa captura no llegó a ejecutarse la parte que avisa a la etapa siguiente, porque store es la última. Así que probé dos variantes más, las dos con un store que tarda 200 µs por medición, como en la prueba de carga. Cuando parse lanzó una InvalidOperationException en la medición 7.000, store guardó las 6.999 mediciones que parse le había pasado, y después su ReadAllAsync lanzó esa misma excepción, no una ChannelClosedException que la envolviera; receive terminó en Canceled. Cuando la que falló en la medición 7.000 fue receive, las tres etapas terminaron en Faulted con su excepción, y todas las mediciones que había enviado se procesaron y se guardaron. Y cuando store lanzó una TaskCanceledException, como hace una inserción que agota su tiempo de espera, el pipeline se detuvo con StageFailedException: The insert timed out. y store terminó en Faulted.
Ahora, la cuenta de lo perdido en la captura de arriba: 7.202 líneas recibidas, 1 rechazada y 6.999 guardadas. Las otras 202 nunca llegaron a la base de datos. Estaban en los dos canales, 100 en cada uno, o en manos de una etapa cuando se detuvo: la medición con la que falló store y la que parse no pudo escribir. (Si lo ejecutas, puede que te salgan 201: depende de si receive alcanza a meter una línea más antes de que le llegue la cancelación.) No es un fallo de la solución. Así funciona un canal: vive en memoria, y ante un error o un reinicio, lo que haya dentro se pierde. Cuando todas las mediciones tienen que sobrevivir, el buffer tiene que ser persistente y el consumidor tiene que confirmar cada elemento después de guardarlo, y ese es el trabajo de un broker de mensajes.
La referencia: BlockingCollection
Antes de los canales, la cola de productor y consumidor estándar en .NET era BlockingCollection<T>, y sigue funcionando. La diferencia está en cómo esperan sus consumidores. GetConsumingEnumerable() bloquea el hilo en el que se ejecuta hasta que llega un elemento, mientras que el ReadAllAsync de un canal espera con await y devuelve el hilo. Para medir lo que eso cuesta, arranqué 64 consumidores sobre una cola vacía, esperé un segundo, encolé un trabajo más de la misma forma en que Kestrel, el servidor web de ASP.NET Core, encola una petición entrante, y medí cuánto tardó en conseguir un hilo:
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading.Channels;
const int Consumers = 64;
int threadsAtStart = Process.GetCurrentProcess().Threads.Count;
Console.WriteLine($"{Environment.ProcessorCount} cores, {Consumers} consumers waiting for work that has not arrived yet");
Console.WriteLine($"{"consumers",-32} {"new threads",11} {"pool threads",12} {"a queued request waited",24}");
// Un consumidor que espera en un canal no ocupa un hilo: solo deja un callback para cuando llegue un elemento.
Channel<int> channel = Channel.CreateBounded<int>(1_000);
Task[] readers = Enumerable.Range(0, Consumers)
.Select(_ => Task.Run(async () => { await foreach (int job in channel.Reader.ReadAllAsync()) { } }))
.ToArray();
await ReportAsync("Channel, await foreach");
channel.Writer.Complete();
await Task.WhenAll(readers);
// BlockingCollection con hilos dedicados: cada consumidor bloquea un hilo propio.
await MeasureBlockingCollectionAsync("BlockingCollection, LongRunning", TaskCreationOptions.LongRunning);
// BlockingCollection en el thread pool, como lo arranca Task.Run en el primer ejemplo de su documentación.
await MeasureBlockingCollectionAsync("BlockingCollection, thread pool", TaskCreationOptions.None);
async Task MeasureBlockingCollectionAsync(string label, TaskCreationOptions options)
{
using BlockingCollection<int> queue = new(boundedCapacity: 1_000);
Task[] consumers = Enumerable.Range(0, Consumers)
.Select(_ => Task.Factory.StartNew(
() => { foreach (int job in queue.GetConsumingEnumerable()) { } },
CancellationToken.None, options, TaskScheduler.Default))
.ToArray();
await ReportAsync(label);
queue.CompleteAdding();
await Task.WhenAll(consumers);
}
async Task ReportAsync(string label)
{
await Task.Delay(TimeSpan.FromSeconds(1));
// QueueUserWorkItem usa la cola global del pool, que es donde Kestrel pone una petición entrante.
TaskCompletionSource started = new(TaskCreationOptions.RunContinuationsAsynchronously);
Stopwatch waited = Stopwatch.StartNew();
ThreadPool.QueueUserWorkItem(_ => started.SetResult());
await started.Task;
int newThreads = Process.GetCurrentProcess().Threads.Count - threadsAtStart;
Console.WriteLine($"{label,-32} {newThreads,11} {ThreadPool.ThreadCount,12} {waited.Elapsed.TotalMilliseconds,21:N1} ms");
}
8 cores, 64 consumers waiting for work that has not arrived yet
consumers new threads pool threads a queued request waited
Channel, await foreach 10 8 8.8 ms
BlockingCollection, LongRunning 75 9 4.8 ms
BlockingCollection, thread pool 65 65 43,093.5 ms
- 64 consumidores esperando en un canal no ocupan ningún hilo. El thread pool se quedó en 8 hilos, uno por núcleo, y el trabajo encolado arrancó en menos de 10 ms.
-
BlockingCollectioncon hilos dedicados, conTaskCreationOptions.LongRunning, cuesta un hilo por consumidor: 64 hilos sin hacer nada, cada uno con su propia pila. No son hilos del pool, así que el trabajo encolado también arrancó en menos de 10 ms. -
BlockingCollectionen el thread pool es donde lo poneTask.Run, y conTask.Runarranca el consumidor el primer ejemplo de su propia documentación. Cada consumidor que espera retiene un hilo del pool, y el pool no distingue un hilo bloqueado de uno ocupado, así que añade hilos despacio. La guía de Microsoft sobre la falta de hilos en el thread pool lo describe: después de un primer salto rápido, añade uno o dos hilos por segundo. El trabajo encolado esperó 43,1 segundos en esta corrida, y entre 37,1 y 40,0 en otras tres. En ASP.NET Core, ese trabajo es una petición.
BlockingCollection no está roto; es síncrono. En una herramienta de consola o en un servicio que corre en sus propios hilos, funciona bien. En código async, un consumidor que espera en él bloquea un hilo que el resto de la aplicación necesita, y un canal hace el mismo trabajo sin ocupar ninguno.
Cuándo usar un canal y cuándo no
Úsalo para:
-
Productor y consumidor en el mismo proceso, como un
BackgroundServicede ASP.NET Core que lee los trabajos que los endpoints escriben en un canal acotado. - Pipelines, en los que cada etapa va a su ritmo y un canal acotado entre dos etapas impide que una rápida inunde a una lenta.
- Absorber ráfagas, con una capacidad calculada a partir de la latencia que puedes aceptar: capacidad × tiempo por elemento.
Usa otra cosa cuando:
- Los elementos tienen que sobrevivir a un fallo o a un despliegue. Un canal es memoria. Usa una cola persistente, como en RabbitMQ de los fundamentos a producción, Parte 2: construir un servicio escalable, o una tabla en la base de datos, y confirma cada elemento cuando el trabajo esté hecho.
- El productor y el consumidor son procesos distintos. La respuesta es la misma.
- Necesitas reintentos, programación de tareas o un panel con los trabajos. Eso es un planificador como Hangfire o Quartz.NET, no una cola.
-
Solo tienes que procesar en paralelo una lista que ya conoces.
Parallel.ForEachAsyncconMaxDegreeOfParallelismes más corto y no deja nada que completar ni vaciar.
Puntos clave
-
En un modo de descarte, una escritura que pierde su elemento sigue devolviendo
true.itemDroppedes la única señal: cuéntalo y publícalo como métrica. -
DropNewestdescarta el elemento más nuevo que ya está en el canal, no el que estás escribiendo. De los tres modos de descarte, soloDropOldestmantuvo al consumidor con datos recientes, con una mediana de espera de 20 ms frente a unos 200. -
Waitnunca pierde un elemento y hace pagar al productor: capacidad × tiempo por elemento es la latencia que eliges. YTryWritenunca espera, ni siquiera en modoWait. -
Una etapa que lanza una excepción detiene todo el pipeline sin avisar. Completa su salida con la excepción y cancela la etapa anterior, esté esperando lo que esté esperando; nunca canceles las siguientes. Un
finally { Complete(); }por sí solo deja el bloqueo donde estaba y hace que la etapa siguiente dé por buena la mitad de los datos. -
BlockingCollectionretiene un hilo por cada consumidor que espera. En el thread pool, 64 de ellos hicieron esperar entre 37 y 43 segundos a un trabajo que no tenía nada que ver.




Top comments (0)