Multithreading in Java: Erste Schritte mit Threads

Was ist ein Thread?

Ein Thread ist ein leichter Prozess. In jedem Prozess können mehrere Threads ausgeführt werden.

In einem Webbrowser können wir beispielsweise einen Thread haben, der die Benutzeroberfläche lädt, und einen anderen Thread, der tatsächlich alle Daten abruft, die in dieser Oberfläche angezeigt werden müssen.

Was ist MultiThreading?

Multithreading ermöglicht es uns, mehrere Threads gleichzeitig auszuführen.

In einem Webbrowser können wir beispielsweise einen Thread haben, der die Benutzeroberfläche verwaltet, und parallel dazu können wir einen anderen Thread haben, der die anzuzeigenden Daten abruft.

Multithreading verbessert also die Reaktionsfähigkeit eines Systems.

Was ist Parallelität?

Die Parallelität im Kontext von Threads ermöglicht es uns, mehrere Threads gleichzeitig auszuführen.

Aber laufen die Threads wirklich gleichzeitig?

Single Core Systeme

Der von der JVM bereitgestellte Thread-Scheduler entscheidet, welcher Thread zu einem bestimmten Zeitpunkt ausgeführt wird. Der Scheduler gibt jedem Thread eine kleine Zeitscheibe.

Wir haben also zu jedem Zeitpunkt nur einen Thread, der tatsächlich im Prozessor ausgeführt wird. Aufgrund der Zeitverschiebung haben wir jedoch das Gefühl, dass mehrere Threads gleichzeitig ausgeführt werden.

Multi-Core-Systeme

Auch in Mehrkernsystemen ist der Thread-Scheduler beteiligt. Da wir jedoch mehrere Kerne haben, können tatsächlich mehrere Threads gleichzeitig ausgeführt werden.

Wenn wir beispielsweise ein Dual-Core-System haben, können genau zwei Threads gleichzeitig ausgeführt werden. Der erste Thread wird im ersten Kern ausgeführt, und der zweite Thread wird im zweiten Kern ausgeführt.

Warum wird Multithreading benötigt?

Multithreading ermöglicht es uns, die Reaktionsfähigkeit eines Systems zu verbessern.

Wenn beispielsweise in einem Webbrowser alles in einem einzigen Thread ausgeführt wird, reagiert das System nicht mehr, wenn Daten zur Anzeige abgerufen werden. Wenn das Abrufen der Daten beispielsweise 10 Sekunden dauert, können wir in diesen 10 Sekunden im Webbrowser nichts anderes tun, als neue Registerkarten zu öffnen oder sogar den Webbrowser zu schließen.

Wenn Sie also verschiedene Teile eines Programms gleichzeitig in verschiedenen Threads ausführen, können Sie die Reaktionsfähigkeit eines Systems verbessern.

So schreiben Sie Multithread-Programme in Java

Wir können Threads in Java wie folgt erstellen

  • Thread-Klasse erweitern
  • Implementierung der ausführbaren Schnittstelle
  • Implementierung der aufrufbaren Schnittstelle
  • Durch Verwendung des Executor-Frameworks zusammen mit ausführbaren und aufrufbaren Aufgaben

Wir werden Callables und das Executor Framework in einem separaten Blog betrachten. In diesem Artikel werde ich mich hauptsächlich auf die Erweiterung der Thread-Klasse und die Implementierung der ausführbaren Schnittstelle konzentrieren.

Thread-Klasse erweitern

Um einen Code zu erstellen, der in einem Thread ausgeführt werden kann, erstellen wir eine Klasse und erweitern dann die Thread- Klasse. Die Aufgabe, die von diesem Code ausgeführt wird, muss in die Funktion run () gestellt werden.

Im folgenden Code sehen Sie, dass Worker eine Klasse ist, die die Thread- Klasse erweitert, und die Aufgabe des Druckens der Nummern 0 bis 5 in der Funktion run () ausgeführt wird.

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

Im obigen Code wird Thread.currentThread (). GetName () verwendet, um den Namen des aktuellen Threads abzurufen , in dem der Code ausgeführt wird.

Um einen Thread zu erstellen , müssen wir nur eine Instanz der Worker-Klasse erstellen. Und dann können wir den Thread mit der Funktion start () starten .

public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

Im obigen Code erstellen wir 3 Threads (t1, t2 und t3) aus der Worker-Klasse. Dann starten wir die Threads mit der Funktion start () .

Hier ist der endgültige Code zum Erstellen eines Threads durch Erweitern einer Thread-Klasse:

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

Hier ist die Ausgabe, die wir erhalten, wenn wir den obigen Code ausführen:

Thread-Klassenausgabe

Sie können sehen, dass alle 3 Threads die Zahlen von 0 bis 5 gedruckt haben.

Sie können auch deutlich an der Ausgabe erkennen, dass die 3 Threads nicht in einer bestimmten Reihenfolge ausgeführt werden

Implementing the Runnable Interface

In order to create a piece of code which can be run in a thread, we create a class and then implement the runnable interface. The task being done by this piece of code needs to be put in the run() function.

In the below code you can see that RunnableWorker is a class which implements runnable interface, and the task of printing numbers 0 to 4 is being done inside the run() function.

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

In order to create a thread, first we need to create an Instance of RunnableWorker which implements the runnable interface.

Then we can create a new thread by creating an instance of the thread class and passing the instance of RunnableWorker as the argument. This is shown in the code below:

public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

The above code creates a runnable instance r. Then it create 3 threads (t1, t2 and t3) and passes r as the argument to the 3 threads. Then the start() function is used to start all 3 threads.

Here is the complete code for creating a thread by implementing the runnable interface:

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

On running the above code, we will get the following output. The sequence of the output will change every time the code is run.

Runnable Interface-Ausgabe

Implementing the runnable interface is a better option than extending the thread class since we can extend only one class, but we can implement multiple interfaces in Java.

Runnable Interface in Java 8

In Java 8, the runnable interface becomes a FunctionalInterface since it has only one function, run().

The below code shows how we can create a runnable instance in Java 8.

public class RunnableFunctionalInterfaceDemo { public static void main(String[] args) { Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

Here, instead of creating a class and then implementing the runnable interface, we can directly use a lambda expression to create a runnable instance as shown below:

Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; 

Code

The code in this article is available in the following GitHub repo: //github.com/aditya-sridhar/basic-threads-demo

Congrats ?

You now know how to create threads by extending the thread class and by implementing the runnable interface.

I will discuss the thread life cycle and challenges while using threads in my next blog post.

My Website: //adityasridhar.com/

Fühlen Sie sich frei, sich mit mir auf LinkedIn zu verbinden oder mir auf Twitter zu folgen