Ausnahmen in klassischen Thread

1. Einführung

Wenn wir mit der Klasse Task oder mit asynchronen Methoden (async/await) arbeiten, können wir Ausnahmen auf die gewohnte Art fangen — per try-catch um das await oder mit Hilfe von ContinueWith. Ausnahmen "gehen nicht verloren", sondern werden in den aufrufenden Thread zurückgegeben.

Wenn wir jedoch einen Thread über Thread erstellen, wird es komplizierter. Jeder Thread hat seinen eigenen Einstiegspunkt (ThreadStart) und seinen eigenen Ausführungskontext. Wenn im Thread eine nicht behandelte Ausnahme auftritt, "kehrt" sie nicht in den Hauptthread zurück — sie wird nur in diesem Thread geworfen.

• In .NET Framework: eine unbehandelte Ausnahme in einem Thread beendet die ganze Anwendung.
• In .NET (Core/5+): nur dieser Thread wird beendet, die Anwendung läuft weiter (was zu versteckten Bugs führen kann).

Fazit: wenn man Ausnahmen im Thread nicht abfängt, sieht man sie höchstwahrscheinlich nicht. Deshalb ist eine korrekte Fehlerbehandlung in Threads notwendig.

Interessante Tatsache: Ausnahmen, die aus einem Thread herausfliegen, sind wie ein unauffindbarer Ninja: sie verschwinden und später wunderst du dich, warum die Logik nicht funktioniert hat.

2. Wie funktionieren Ausnahmen innerhalb eines Threads?

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread thread = new Thread(DoWork);
        thread.Start();

        // Wir warten auf das Ende des Threads, um zu sehen, was passiert
        thread.Join();

        Console.WriteLine("Main ist normal beendet");
    }

    static void DoWork()
    {
        Console.WriteLine("Wir arbeiten in einem separaten Thread...");
        throw new Exception("Oh nein! Im Thread ist ein Fehler aufgetreten.");
    }
}

Je nach Plattform (altes .NET Framework oder modernes .NET Core/5/6/7/8/9) wird das Verhalten unterschiedlich sein: entweder stürzt die ganze Anwendung ab, oder nur der Thread. Aber das Wichtigste — die Ausnahme kommt nicht im Hauptthread an, und du kannst sie von außen nicht behandeln.

Wichtig! Der Versuch, thread.Join() in ein try-catch zu packen, hilft nicht, eine Ausnahme aus einem anderen Thread zu fangen — sie "lebt" und "stirbt" innerhalb dieses Threads.

3. Wie sollte man Ausnahmen in Thread fangen?

Nur innerhalb des Threads — in der Funktion, die du dem Konstruktor von Thread übergibst. Alles, was Fehler werfen kann, sollte in try-catch gewickelt werden.

static void DoWork()
{
    try
    {
        Console.WriteLine("Wir arbeiten...");
        throw new Exception("Wieder ist etwas schief gelaufen!");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"[Thread] Ausnahme gefangen: {ex.Message}");
        // Hier kann man loggen, an das UI/den Server schicken usw.
    }
}

Die Fehlerbehandlung in Threads ist die Verantwortung des Thread-Codes. Man darf nicht darauf hoffen, dass der aufrufende Code den Fehler automatisch fängt.

4. Wie erfährt der Hauptthread, dass in einem anderen etwas schiefgelaufen ist?

In realen Anwendungen ist es wichtig, die Fehlerinformationen in den Hauptthread zu bringen.

• Benutze thread-safe Mechanismen, z.B. ConcurrentQueue<Exception>, um Ausnahmen aus Threads zu übermitteln.
• Feuere Events/Delegates aus dem Arbeiter-Thread.
• Bevorzuge Task, der die Ausnahme beim await "out of the box" liefert.

Beispiel: sammeln der Ausnahme an einem speziellen Ort

using System;
using System.Threading;

class Program
{
    static Exception? threadException = null;

    static void Main()
    {
        Thread thread = new Thread(DoWork);
        thread.Start();
        thread.Join();

        if (threadException != null)
        {
            Console.WriteLine($"In einem anderen Thread ist ein Fehler aufgetreten: {threadException.Message}");
        }
        else
        {
            Console.WriteLine("Der Thread ist ohne Fehler beendet worden.");
        }
    }

    static void DoWork()
    {
        try
        {
            throw new Exception("Problem in einem anderen Thread!");
        }
        catch (Exception ex)
        {
            threadException = ex;
        }
    }
}

Hinweis: dieser Ansatz ist geeignet, wenn man synchron wartet (Join()). Wenn der Thread "sein eigenes Leben führt" oder es viele Fehler gibt — benutze ConcurrentQueue<Exception>, Events oder andere Kommunikationsmechanismen.

5. Vergleich mit Task: warum die Fehlerbehandlung einfacher ist

async Task FooAsync()
{
    throw new Exception("Fehler in der Task!");
}

try
{
    await FooAsync();
}
catch (Exception ex)
{
    Console.WriteLine($"Fehler gefangen: {ex.Message}");
}

Hier ist alles transparent: der Fehler "kommt an" dort an, wo du await benutzt. Bei klassischen Threads bleibt der Fehler im Thread und wird ohne spezielle Maßnahmen nicht nach oben durchgereicht. Das ist eines der Argumente für die Verwendung von Task und modernen Abstraktionen.

6. Praktisches Beispiel

In UI-Anwendungen (WPF/WinForms) werden Threads genutzt, um die Oberfläche nicht zu blockieren. Unbehandelte Ausnahmen führen zu einem "grauen Bildschirm" und merkwürdigen Hängern.

Schlecht (Thread ohne Fehlerbehandlung)

Thread thread = new Thread(() =>
{
    // Lange Berechnung
    Thread.Sleep(5000);
    throw new Exception("Alles ist verloren!"); // niemand fängt das
});
thread.Start();

Gut (Fehler fangen und Benutzer benachrichtigen)

Thread thread = new Thread(() =>
{
    try
    {
        Thread.Sleep(5000);
        throw new Exception("Etwas stimmt nicht");
    }
    catch (Exception ex)
    {
        // Man kann MessageBox zeigen, loggen oder an das UI weiterreichen
        Console.WriteLine($"Fehler im Thread: {ex.Message}");
    }
});
thread.Start();

7. Nützliche Feinheiten

Globaler Hook für unbehandelte Thread-Ausnahmen

AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
{
    Console.WriteLine($"Global gefangener Fehler: {((Exception)args.ExceptionObject).Message}");
};

Thread thread = new Thread(() =>
{
    throw new Exception("Exterminatus!");
});
thread.Start();

Der Handler AppDomain.CurrentDomain.UnhandledException reagiert auf unbehandelte Ausnahmen in Threads, erlaubt aber nicht, den Thread "wiederzubeleben" oder das Verhindern des Prozessabbruchs in .NET Framework. In .NET (Core/5+) loggt er den Fehler; die Anwendung kann weiterlaufen, wenn andere Threads aktiv sind.

Unterschiede in der Ausnahmebehandlung — Thread vs Task

Thread

Task

8. Typische Fehler bei der Arbeit mit Ausnahmen in Thread

Fehler Nr.1: fangen keine Ausnahmen innerhalb des Threads.
Das kann zu einem stillen Beenden eines Anwendungsbereichs oder manchmal des gesamten Prozesses führen, oft ohne klare Diagnose.

Fehler Nr.2: versuchen, die Ausnahme aus dem Thread im Hauptthread zu "fangen".
Das funktioniert nicht: ein try-catch um thread.Join() oder thread.Start() wird die im Thread geworfene Ausnahme nicht abfangen.

Fehler Nr.3: verlieren die Fehlerinformation.
Wenn der Thread abgestürzt ist und du die Ausnahme nicht explizit weitergegeben hast (Variable, Queue, Event), kennst du weder Ursache noch Details. Das führt zu "geisterhaften" Bugs.

Fehler Nr.4: fehlendes Logging.
Logge immer Ausnahmen in Threads, selbst wenn es scheint, dass "nichts Schlimmes" passiert.