Threads in Java

Einführung in Threads

• Definition und Grundlagen von Threads:
  • Ein Thread ist die kleinste Ausführungseinheit eines Prozesses. Threads teilen sich den gleichen Adressraum des Prozesses, was bedeutet, dass sie gemeinsam auf dessen Daten und Ressourcen zugreifen können.
• Unterschied zwischen Prozessen und Threads:
  • Ein Prozess ist ein eigenständiges Programm, das in einer eigenen Speicherumgebung läuft. Threads sind "leichte" Prozesse, die innerhalb eines Prozesses laufen. Threads teilen den gleichen Speicher und andere Ressourcen des Prozesses, wodurch eine schnellere Kommunikation und ein geringerer Overhead erreicht werden.

• Vorteile und Herausforderungen:
  • Vorteile: Erhöhung der Anwendungsleistung durch parallele Ausführung, bessere Ressourcenausnutzung und schnellere Reaktionsfähigkeit.
  • Herausforderungen: Synchronisationsprobleme wie Race Conditions und Deadlocks, komplexere Fehlerbehandlung und erhöhte Anfälligkeit für nicht-deterministische Fehler.

• Thread-Zustände: (Details später)
  • Unstarted: Der Thread wurde erstellt, aber noch nicht gestartet.
  • Running: Der Thread wird ausgeführt.
  • Waiting/Blocked: Der Thread wartet auf eine Ressource oder eine andere Bedingung, um fortzufahren.
  • Sleeping: Der Thread wurde absichtlich pausiert (z.B. durch Thread.sleep()).
  • Stopped/Terminated: Der Thread hat seine Ausführung beendet.

• Context und Context Switch:
  • Der Kontext eines Threads umfasst seinen aktuellen Zustand, Registerwerte, den Program Counter, den Stack, etc. Der Kontext muss gespeichert und wiederhergestellt werden, wenn ein anderer Thread ausgeführt wird.
  • Der Wechsel der Ausführung von einem Thread zu einem anderen. Der Scheduler des Betriebssystems speichert den Kontext des aktuellen Threads und lädt den Kontext des nächsten Threads. Context Switches sind teuer in Bezug auf die Leistung.

Threads in Java

Erweiterung der Thread-Klasse

1. Erweitern der Thread-Klasse:

public class MyThread extends Thread {
    public void run() {
        // Code für den Thread
    }
}

1. Erstellen und Starten eines Threads:

MyThread myThread = new MyThread();
myThread.start();

Implementierung des Runnable-Interfaces

1. Implementieren des Runnable-Interfaces:

public class MyRunnable implements Runnable {
    public void run() {
        // Code für den Thread
    }
}

1. Erstellen und Starten eines Threads:

MyRunnable myRunnable = new MyRunnable();
Thread myThread = new Thread(myRunnable);
myThread.start();

Anonyme Klassen und Lambda-Ausdrücke

1. Verwendung anonymer Klassen:

Thread myThread = new Thread(new Runnable() {
    public void run() {
        // Code für den Thread
    }
});
myThread.start();

1. Verwendung von Lambda-Ausdrücken:

Thread myThread = new Thread(() -> {
    // Code für den Thread
});
myThread.start();

Synchronisation von Threads

• Race Conditions und Deadlocks:
  • Race Conditions: Tritt auf, wenn mehrere Threads gleichzeitig auf gemeinsame Ressourcen zugreifen und das Endergebnis von der Reihenfolge der Zugriffe abhängt.
  • Deadlocks: Eine Situation, in der zwei oder mehr Threads für immer auf Ressourcen warten, die von den anderen gehalten werden, wodurch alle betroffenen Threads blockiert werden.

• Lösung mit Atomic Variablen:
  • AtomicInteger: Eine atomare Variable, die Operationen wie increment() und decrement() atomar ausführt.

import java.util.concurrent.atomic.AtomicInteger;
class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

Deadlocks

• Voraussetzungen für Deadlocks:
  • Gegenseitiger Ausschluss: Eine Ressource kann immer nur von einem Thread gleichzeitig genutzt werden.
  • Halten und Warten: Ein Thread, der eine Ressource hält, wartet auf eine zusätzliche Ressource.
  • Keine Präemption: Eine Ressource kann nicht zwangsweise von einem Thread entzogen werden.
  • Zirkuläres Warten: Ein zyklischer Wartegraph, bei dem jeder Thread auf eine Ressource wartet, die von einem anderen gehalten wird.

• Vermeidung von Deadlocks:
  • Ressourcenreihenfolge: Konsistente Reihenfolge beim Anfordern von Ressourcen verwenden.
  • Ressourcenausbeutung: Sicherstellen, dass ein Thread alle benötigten Ressourcen auf einmal erhält.
  • Timeout-Mechanismen: Zeitbegrenzungen für das Warten auf Ressourcen.

• Ressource Allocation Graph:
  • Ein Diagramm, das Threads und Ressourcen darstellt und zeigt, welche Ressourcen von welchen Threads gehalten oder angefordert werden. Wird verwendet, um mögliche Deadlocks zu identifizieren. (siehe oben)
• Deadlocks zur Laufzeit erkennen und auflösen:
  • Erkennung: Analyse-Tools und Algorithmen zur Deadlock-Erkennung können genutzt werden, um Deadlocks zur Laufzeit zu identifizieren.
  • Auflösung: Threads, die Teil eines Deadlocks sind, können abgebrochen oder neu gestartet werden. Eine andere Möglichkeit ist die Freigabe von Ressourcen, um den Deadlock zu beheben.

Thread-Prioritäten

• Thread-Prioritäten in Java:
  • Jeder Thread hat eine Priorität, die bestimmt, wie oft der Thread vom Scheduler des Betriebssystems ausgeführt wird.
  • Prioritäten reichen von 1 (niedrigste Priorität) bis 10 (höchste Priorität).
  • Standardpriorität: Thread.NORM_PRIORITY (5).
  • Prioritäten können mit setPriority() festgelegt werden.
  • Höhere Prioritäten bedeuten nicht unbedingt, dass der Thread schneller ausgeführt wird.

Weitere Synchronisationsmöglichkeiten in Java

• ReentrantLock: Feinere Kontrolle über Sperren
• ReadWriteLock: Effizient für viele Lesezugriffe
• Semaphore: Begrenzung gleichzeitiger Zugriffe
• CountDownLatch: Wartet auf eine Gruppe von Threads
• CyclicBarrier: Threads synchronisieren sich regelmäßig
• Exchanger: Direkter Datenaustausch zwischen zwei Threads

Collections und Threads

• Nicht-synchronisierte Collections:
  • ArrayList, HashMap, HashSet, etc.
  • Nicht thread-sicher, daher nicht für parallele Zugriffe geeignet (Race Conditions).
  • Verwendung in Single-Thread-Anwendungen oder mit externer Synchronisation.
  • Beispiel: Collections.synchronizedList(new ArrayList<>()).
• Synchronisierte Collections:
  • Vector, Hashtable, ConcurrentHashMap, CopyOnWriteArrayList, etc.
  • Thread-sicher, für parallele Zugriffe geeignet.
  • Verwendung in Multi-Thread-Anwendungen ohne externe Synchronisation.

Zusammenfassung

• Threads sind die kleinste Ausführungseinheit eines Prozesses.
• Thread-Zustände: Unstarted, Running, Waiting/Blocked, Sleeping, Stopped/Terminated.
• Synchronisation ist erforderlich (Vorsicht! Mögliche Deadlocks).

Ausblick auf fortgeschrittene Themen

• Thread-Pools: Verwalten und wiederverwenden von Threads.
• Executor-Framework: Vereinfachte Verwaltung von Threads.
• Fork-Join-Framework: Parallele Verarbeitung von Aufgaben.
• Reactive Programming: Asynchrone und ereignisgesteuerte Programmierung.
• Parallel Streams: Parallele Verarbeitung von Streams.
• CompletableFuture: Kombination von asynchronen Operationen.
• Lock-Free Programming: Vermeidung von Synchronisationsmechanismen.
• Actor Model: Nachrichtenbasierte Kommunikation zwischen Threads.