Java-Thread-Klasse

Die Thread-Klasse ist eine Kernklasse in Java zum Erstellen und Verwalten von Threads.

In Java ist jeder Thread eine Instanz der Thread-Klasse. Ein Thread kann als eine unabhängig ausgeführte "Teilaufgabe" in einem Programm verstanden werden, wodurch das Programm mehrere Vorgänge gleichzeitig ausführen kann.

Es gibt zwei Möglichkeiten, Threads in Java zu erstellen:

  1. Die Thread-Klasse erweitern
  2. Das Runnable-Interface implementieren

Grundlegende Verwendung der Thread-Klasse

Threads erstellen

Beispiel

// Methode 1: Die Thread-Klasse erweitern
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}

// Methode 2: Das Runnable-Interface implementieren
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        // Verwendung des Vererbungsansatzes
        MyThread thread1 = new MyThread();
        thread1.start();
       
        // Verwendung des Interface-Ansatzes
        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
    }
}

Thread-Lebenszyklus

Java-Threads haben die folgenden Zustände:

  • NEW: Neu erstellter Thread, die start()-Methode wurde noch nicht aufgerufen
  • RUNNABLE: Lauffähiger Zustand, kann ausgeführt werden oder auf CPU-Zeit warten
  • BLOCKED: Thread ist blockiert und wartet darauf, die Monitor-Sperre zu erwerben
  • WAITING: Wartezustand, wartet darauf, dass andere Threads bestimmte Operationen ausführen
  • TIMED_WAITING: Zeitlich begrenzter Wartezustand
  • TERMINATED: Thread wurde beendet

Häufige Methoden der Thread-Klasse

Grundlegende Steuerungsmethoden

Beispiel

Thread thread = new Thread(() -> {
    System.out.println("Thread executing");
});

thread.start();  // Thread starten
thread.join();   // Warte, bis der Thread beendet ist
thread.sleep(1000); // Thread schläft 1 Sekunde

Thread-Priorität

Beispiel

thread.setPriority(Thread.MAX_PRIORITY);  // Höchste Priorität (10)
thread.setPriority(Thread.NORM_PRIORITY); // Standardpriorität (5)
thread.setPriority(Thread.MIN_PRIORITY);  // Niedrigste Priorität (1)

Thread-Unterbrechung

Beispiel

thread.interrupt(); // Den Thread unterbrechen

// Interrupt-Status im Thread prüfen
if (Thread.interrupted()) {
    // Interrupt-Logik behandeln
}

Thread-Synchronisation

Wenn mehrere Threads auf gemeinsam genutzte Ressourcen zugreifen, müssen Synchronisationsmechanismen verwendet werden, um Probleme mit Dateninkonsistenzen zu vermeiden.

Verwendung des synchronized-Schlüsselworts

Beispiel

class Counter {
    private int count = 0;
   
    public synchronized void increment() {
        count++;
    }
}

Verwendung der Lock-Schnittstelle

Beispiel

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();
   
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

Thread-Pool⟦

In der tatsächlichen Entwicklung werden Thread-Pools üblicherweise verwendet, um Threads zu verwalten, anstatt Thread-Objekte zu erstellen.

Beispiel

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
       
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                System.out.println("Thread executing task");
            });
        }
       
        executor.shutdown();
    }
}

Best Practices

  1. Bevorzugen Sie das Erstellen von Threads über das Runnable-Interface
  2. Verwenden Sie Thread-Pools, um Thread-Ressourcen zu verwalten
  3. Vermeiden Sie übermäßige Synchronisation; verwenden Sie Synchronisationsmechanismen nur, wenn nötig
  4. Verwenden Sie das Schlüsselwort volatile, um die Sichtbarkeit von Variablen sicherzustellen
  5. Erwägen Sie die Verwendung der fortgeschrittenen Hilfsklassen im Java-Nebenläufigkeitspaket (java.util.concurrent)

Durch die sinnvolle Nutzung der Klasse Thread und verwandter Nebenläufigkeitswerkzeuge können Sie effiziente und zuverlässige Multithread-Java-Programme schreiben.

Weitere Erweiterungen