DEV Community

Cover image for System.Threading.Channels en .NET 10, medido: la escritura devolvió true y el elemento ya no estaba
Juan Gómez
Juan Gómez

Posted on

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

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)}]");
}
Enter fullscreen mode Exit fullscreen mode
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]
Enter fullscreen mode Exit fullscreen mode

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);
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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);
Enter fullscreen mode Exit fullscreen mode
Still running after 10 s. receive: WaitingForActivation, parse: Faulted, store: WaitingForActivation
received 5,101, parsed 5,000, stored 5,000, waiting in lines: 100
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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, 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);
Enter fullscreen mode Exit fullscreen mode
Pipeline stopped: IOException: Database connection lost.
receive: Canceled, parse: Canceled, store: Faulted
received 7,202, rejected 1, parsed 7,100, stored 6,999
Enter fullscreen mode Exit fullscreen mode

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; parse lanzó 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 ReadAllAsync lanza la excepción original.
  • Una OperationCanceledException que 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 en Canceled, así que quien trate OperationCanceledException como un apagado normal se tragaría una caída. El filtro when la envuelve en una StageFailedException.
  • Una etapa que detuvo el propio pipeline termina en Canceled, no en Faulted, así que no añade nada a lo que informa Task.WhenAll, y la excepción que recibes es la causa.
  • store pasa complete: null porque es la última etapa y no tiene canal de salida. Y Task.Run arranca 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.

Tres estaciones unidas por cintas transportadoras: la 1 sostiene un cubo con la cinta siguiente llena, la 2 está detenida con una señal de advertencia y un engranaje roto, y la 3 espera vacía bajo un reloj de arena

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");
}
Enter fullscreen mode Exit fullscreen mode
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
Enter fullscreen mode Exit fullscreen mode
  • 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.
  • BlockingCollection con hilos dedicados, con TaskCreationOptions.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.
  • BlockingCollection en el thread pool es donde lo pone Task.Run, y con Task.Run arranca 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.

A la izquierda, carretes de hilo atados a cajas dormidas mientras una larga fila de sobres espera delante; a la derecha, fichas clavadas en un tablero y carretes libres, uno de ellos ya recibiendo un sobre

Cuándo usar un canal y cuándo no

Úsalo para:

  • Productor y consumidor en el mismo proceso, como un BackgroundService de 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.ForEachAsync con MaxDegreeOfParallelism es 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. itemDropped es la única señal: cuéntalo y publícalo como métrica.
  • DropNewest descarta el elemento más nuevo que ya está en el canal, no el que estás escribiendo. De los tres modos de descarte, solo DropOldest mantuvo al consumidor con datos recientes, con una mediana de espera de 20 ms frente a unos 200.
  • Wait nunca pierde un elemento y hace pagar al productor: capacidad × tiempo por elemento es la latencia que eliges. Y TryWrite nunca espera, ni siquiera en modo Wait.
  • 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.
  • BlockingCollection retiene 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)