Java Thread Beispiel

Willkommen beim Java-Thread-Beispiel. Prozess und Thread sind zwei grundlegende Ausführungseinheiten. Die nebenläufige Programmierung befasst sich mehr mit Java-Threads.

Prozess

A process is a self contained execution environment and it can be seen as a program or application. However a program itself contains multiple processes inside it. Java runtime environment runs as a single process which contains different classes and programs as processes.

Thread

Ein Thread kann als leichtgewichtiger Prozess bezeichnet werden. Ein Thread benötigt weniger Ressourcen zum Erstellen und existiert im Prozess; er teilt die Prozessressourcen.

Java-Thread-Beispiel

Jede Java-Anwendung hat mindestens einen Thread – den Hauptthread. Obwohl im Hintergrund viele andere Java-Threads wie Speicherverwaltung, Systemverwaltung, Signalverarbeitung usw. laufen, ist aus der Anwendungssicht der Hauptthread der erste Java-Thread, von dem aus wir mehrere Threads erstellen können. Multithreading bezieht sich darauf, dass zwei oder mehr Threads gleichzeitig in einem einzigen Programm ausgeführt werden. Ein Computer-Einzelkernprozessor kann jeweils nur einen Thread ausführen, und das Zeitscheiben-Feature des Betriebssystems teilt die Prozessorzeit zwischen verschiedenen Prozessen und Threads.

Vorteile von Java-Threads

1. Java-Threads sind im Vergleich zu Prozessen leichtgewichtig, es dauert weniger Zeit und Ressourcen, um einen Thread zu erstellen.
2. Threads teilen die Daten und den Code ihres übergeordneten Prozesses
3. Das Umschalten zwischen Threads ist normalerweise weniger aufwendig als zwischen Prozessen.
4. Die Kommunikation zwischen Threads ist in der Regel einfacher als die Kommunikation zwischen Prozessen.

Java bietet zwei Möglichkeiten, einen Thread programmatisch zu erstellen.

1. Implementierung des java.lang.Runnable-Interfaces.
2. Erweiterung der Klasse java.lang.Thread.

Java-Thread-Beispiel – Implementierung des Runnable-Interfaces

Um eine Klasse ausführbar zu machen, können wir das java.lang.Runnable-Interface implementieren und die Implementierung in der Methode public void run() bereitstellen. Um diese Klasse als Thread zu verwenden, müssen wir ein Thread-Objekt erstellen, indem wir ein Objekt dieser ausführbaren Klasse übergeben, und dann die Methode start() aufrufen, um die Methode run() in einem separaten Thread auszuführen. Hier ist ein Java-Thread-Beispiel durch Implementierung des Runnable-Interfaces.

package com.journaldev.threads;

public class HeavyWorkRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Doing heavy processing - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Datenbankverbindung herstellen, ungenutzte Daten aus der DB löschen
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Doing heavy processing - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }

}

Java-Thread-Beispiel – Erweiterung der Thread-Klasse

Wir können die java.lang.Thread-Klasse erweitern, um unsere eigene Java-Thread-Klasse zu erstellen und die Methode run() zu überschreiben. Dann können wir ein Objekt davon erstellen und die Methode start() aufrufen, um unsere benutzerdefinierte Java-Thread-Klasse auszuführen. Hier ist ein einfaches Java-Thread-Beispiel, das zeigt, wie die Thread-Klasse erweitert wird.

package com.journaldev.threads;

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("MyThread - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Datenbankverbindung herstellen, ungenutzte Daten aus der DB löschen
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("MyThread - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }
    
}

Hier ist ein Testprogramm, das zeigt, wie ein Java-Thread erstellt und ausgeführt wird.

package com.journaldev.threads;

public class ThreadRunExample {

    public static void main(String[] args){
        Thread t1 = new Thread(new HeavyWorkRunnable(), "t1");
        Thread t2 = new Thread(new HeavyWorkRunnable(), "t2");
        System.out.println("Starting Runnable threads");
        t1.start();
        t2.start();
        System.out.println("Runnable Threads has been started");
        Thread t3 = new MyThread("t3");
        Thread t4 = new MyThread("t4");
        System.out.println("Starting MyThreads");
        t3.start();
        t4.start();
        System.out.println("MyThreads has been started");
        
    }
}

Die Ausgabe des obigen Java-Thread-Beispielprogramms lautet:

Starting Runnable threads
Runnable Threads has been started
Doing heavy processing - START t1
Doing heavy processing - START t2
Starting MyThreads
MyThread - START Thread-0
MyThreads has been started
MyThread - START Thread-1
Doing heavy processing - END t2
MyThread - END Thread-1
MyThread - END Thread-0
Doing heavy processing - END t1

Sobald wir einen Thread starten, hängt seine Ausführung von der Implementierung des Betriebssystems ab, und wir können ihre Ausführung nicht kontrollieren. Wir können jedoch die Priorität der Threads festlegen, aber selbst dann wird nicht garantiert, dass der Thread mit höherer Priorität zuerst ausgeführt wird. Führen Sie das obige Programm mehrmals aus, und Sie werden feststellen, dass es kein Muster für den Start und das Ende der Threads gibt.

Runnable vs Thread

Wenn Ihre Klasse mehr Funktionalität bietet als nur als Thread ausgeführt zu werden, sollten Sie das Runnable-Interface implementieren, um eine Möglichkeit zum Ausführen als Thread bereitzustellen. Wenn das einzige Ziel Ihrer Klasse darin besteht, als Thread ausgeführt zu werden, können Sie die Thread-Klasse erweitern. Die Implementierung von Runnable ist bevorzugt, da Java die Implementierung mehrerer Interfaces unterstützt. Wenn Sie die Thread-Klasse erweitern, können Sie keine anderen Klassen erweitern. Tipp: Wie Sie bemerkt haben, gibt ein Thread keinen Wert zurück. Aber was ist, wenn wir möchten, dass unser Thread eine Verarbeitung durchführt und dann das Ergebnis an unser Client-Programm zurückgibt? Schauen Sie sich unsere Java Callable Future an. Aktualisierung: Ab Java 8 ist Runnable ein funktionales Interface, und wir können Lambda-Ausdrücke verwenden, um seine Implementierung bereitzustellen, anstatt eine anonyme Klasse zu verwenden. Weitere Details finden Sie in Java 8 Funktionale Interfaces.