0Pricing
C# Academy · Lektion

Abwägung zwischen Durchsatz und Latenz

Bringen Sie die Gesamtarbeit pro Sekunde (Durchsatz) und die Zeit pro Element (Latenz) ins Gleichgewicht. Vergleichen Sie Einzelverarbeitung, Stapelverarbeitung und die Abstimmung des Parallelitätsgrads.

Abwägung zwischen Durchsatz und Latenz ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Durchsatz und Latenz

Definitionen:

  • Durchsatz: Elemente pro Sekunde
  • Latenz: Zeit bis zum Abschluss eines Elements
  • Zielkonflikt: Batching und höhere Parallelität können den Durchsatz erhöhen, einzelne Elemente jedoch verzögern

Verarbeitung pro Element

Bearbeiten Sie jedes Element, sobald es eintrifft: minimale Wartezeit pro Element, aber der Overhead fällt für jedes Element erneut an.

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  // Simulate small per-item cost
  static void HandleItem(int x)
  {
    // Fixed overhead per item
    Thread.SpinWait(20000); // tiny CPU work
  }

  public static void Main(string[] args)
  {
    int n = 200;
    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < n; i++)
    {
      HandleItem(i);         // process immediately (no batching)
      // emit result right away (low latency style)
    }
    sw.Stop();
    Console.WriteLine("Per-item style: {0} ms for {1} items", sw.ElapsedMilliseconds, n);
  }
}

Batch-Verarbeitung

Batching reduziert wiederholten Overhead und erhöht den Durchsatz, aber frühe Elemente warten, bis der Batch gefüllt ist (höhere Latenz).

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

public class Program
{
  static void ProcessBatch(List<int> batch)
  {
    // Amortize overhead across the whole batch
    Thread.SpinWait(20000);        // one-time overhead
    for (int i = 0; i < batch.Count; i++)
    {
      // small per-record work
      int val = batch[i] * 2;
      if (val == int.MinValue) { } // keep compiler from dropping work
    }
  }

  public static void Main(string[] args)
  {
    int n = 200;
    int batchSize = 20;
    List<int> current = new List<int>(batchSize);

    Stopwatch sw = Stopwatch.StartNew();
    for (int i = 0; i < n; i++)
    {
      current.Add(i);
      if (current.Count == batchSize)
      {
        ProcessBatch(current);
        current.Clear(); // emit results after the batch finishes
      }
    }
    if (current.Count > 0) ProcessBatch(current);
    sw.Stop();

    Console.WriteLine("Batch style: {0} ms for {1} items (batch={2})", sw.ElapsedMilliseconds, n, batchSize);
  }
}

Parallelität abstimmen

Das Anpassen von MaxDegreeOfParallelism kann den Durchsatz bei CPU-gebundener Arbeit erhöhen; ein zu hoher Wert kann durch Kontextwechsel schaden.

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  static void Work(int x)
  {
    // CPU-bound unit
    Thread.SpinWait(40000);
  }

  public static void Main(string[] args)
  {
    int[] data = new int[200];
    for (int i = 0; i < data.Length; i++) data[i] = i;

    foreach (int dop in new int[] { 1, 2, 4 })
    {
      var opt = new ParallelOptions();
      opt.MaxDegreeOfParallelism = dop;

      Stopwatch sw = Stopwatch.StartNew();
      Parallel.ForEach(data, opt, Work);
      sw.Stop();

      Console.WriteLine("DOP={0} -> {1} ms", dop, sw.ElapsedMilliseconds);
    }
  }
}

Micro-Batch-Idee

Micro-Batches können beide Ziele ausbalancieren: besserer Durchsatz als bei der Verarbeitung einzelner Elemente, geringere Latenz als bei sehr großen Batches.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  static void ProcessBatch(List<int> batch)
  {
    Thread.SpinWait(15000); // small shared overhead
    for (int i = 0; i < batch.Count; i++) Thread.SpinWait(2000);
  }

  public static void Main(string[] args)
  {
    int n = 200;
    int micro = 5; // micro-batch size
    List<int> buf = new List<int>(micro);
    Stopwatch sw = Stopwatch.StartNew();

    for (int i = 0; i < n; i++)
    {
      buf.Add(i);
      if (buf.Count == micro)
      {
        ProcessBatch(buf);
        buf.Clear(); // emit more frequently than big batches
      }
    }
    if (buf.Count > 0) ProcessBatch(buf);

    sw.Stop();
    Console.WriteLine("Micro-batch (size={0}): {1} ms", micro, sw.ElapsedMilliseconds);
  }
}

Tipps zur Optimierung

Optimierungsleitfaden:

  • Messen Sie sowohl ms/item als auch items/sec
  • Probieren Sie zuerst Micro-Batches aus
  • Erhöhen Sie die Parallelität langsam; beobachten Sie CPU-Auslastung und Kontextwechsel
  • Begrenzen Sie Warteschlangen, um lange Wartezeiten und Speicherwachstum zu vermeiden

Zielkonflikt zwischen Durchsatz und Latenz

Schnelltest: Welche Änderung verbessert typischerweise den Durchsatz, kann aber die Latenz pro Element erhöhen?

Zusammenfassung

Zusammenfassung: Verarbeitung pro Element = geringe Latenz, geringerer Durchsatz. Große Batches/hoher Grad der Parallelität = höherer Durchsatz, höhere Latenz. Micro-Batches und sorgfältige Anpassung des Grads der Parallelität helfen, beides auszubalancieren.

Häufig gestellte Fragen

Ist die Lektion „Abwägung zwischen Durchsatz und Latenz“ kostenlos?

Ja — der vollständige Text von „Abwägung zwischen Durchsatz und Latenz“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Abwägung zwischen Durchsatz und Latenz“?

Bringen Sie die Gesamtarbeit pro Sekunde (Durchsatz) und die Zeit pro Element (Latenz) ins Gleichgewicht. Vergleichen Sie Einzelverarbeitung, Stapelverarbeitung und die Abstimmung des Parallelitätsgr… Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.

Wie lange dauert die Lektion „Abwägung zwischen Durchsatz und Latenz“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Parallel.ForEach, PLINQ
  2. Producer/Consumer mit Channels (Überblick)
  3. Abwägung zwischen Durchsatz und Latenz
← Zurück zu C# Academy