19 Multithreading in Java

19.1 Erstellen von Threads

In Java können Threads auf zwei Hauptarten erstellt werden: durch Ableitung von der Thread-Klasse oder durch Implementierung des Runnable-Interfaces.

19.1.1 Erben von Thread

class MyThread extends Thread {
    public void run() {
        // Code, der im Thread ausgeführt wird
    }
}

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

19.1.2 Implementieren von Runnable

class MyRunnable implements Runnable {
    public void run() {
        // Code, der im Thread ausgeführt wird
    }
}

Thread t2 = new Thread(new MyRunnable());
t2.start();

19.2 Synchronisation

Synchronisation ist erforderlich, wenn mehrere Threads gemeinsam auf geteilte Ressourcen zugreifen.

19.2.1 synchronized-Block

Mit dem synchronized-Block kann der Zugriff auf gemeinsam genutzte Ressourcen synchronisiert werden.

class SharedResource {
    synchronized void sharedMethod() {
        // Zugriff auf gemeinsame Ressource
    }
}

19.2.2 Locks und Conditions

Die Lock- und Condition-Interfaces bieten eine erweiterte Synchronisationssteuerung.

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

class SharedResourceWithLock {
    private final Lock lock = new ReentrantLock();

    void sharedMethod() {
        lock.lock();
        try {
            // Zugriff auf gemeinsame Ressource
        } finally {
            lock.unlock();
        }
    }
}

Multithreading ist eine Technik, die die Ausführung mehrerer Threads innerhalb eines Programms ermöglicht. In Java werden dafür verschiedene Mechanismen und APIs bereitgestellt. Man kann entweder die Thread-Klasse erweitern oder das Runnable-Interface implementieren, um einen Thread zu erstellen. Die Synchronisation wird durch synchronized-Blöcke und Lock- und Condition-Objekte ermöglicht, um den sicheren Zugriff auf geteilte Ressourcen zu gewährleisten.