Es gibt zwei Möglichkeiten, einen Thread zu erstellen:

1. Durch Erweiterung der Thread-Klasse
2. Durch die Implementierung der Runnable-Schnittstelle.

Thread-Klasse:

Die Thread-Klasse stellt Konstruktoren und Methoden zum Erstellen und Ausführen von Vorgängen für einen Thread bereit. Die Thread-Klasse erweitert die Object-Klasse und implementiert die Runnable-Schnittstelle.

Häufig verwendete Konstruktoren der Thread-Klasse:

• Faden()
• Thread(String-Name)
• Thread(Runnable r)
• Thread(Ausführbares r,Stringname)

Häufig verwendete Methoden der Thread-Klasse:

public void run(): wird verwendet, um eine Aktion für einen Thread auszuführen. public void start(): startet die Ausführung des Threads. JVM ruft die run()-Methode für den Thread auf. öffentlicher Leerschlaf (lange Millisekunden): Bewirkt, dass der aktuell ausgeführte Thread für die angegebene Anzahl von Millisekunden in den Ruhezustand versetzt (die Ausführung vorübergehend anhält). public void join(): wartet darauf, dass ein Thread stirbt. öffentlicher Void-Join (lange Millisekunden): wartet für die angegebenen Millisekunden darauf, dass ein Thread stirbt. public int getPriority(): gibt die Priorität des Threads zurück. public int setPriority(int priorität): Ändert die Priorität des Threads. öffentlicher String getName(): gibt den Namen des Threads zurück. public void setName(String name): ändert den Namen des Threads. öffentlicher Thread currentThread(): gibt die Referenz des aktuell ausgeführten Threads zurück. public int getId(): gibt die ID des Threads zurück. public Thread.State getState(): gibt den Status des Threads zurück. öffentlicher boolescher Wert isAlive(): testet, ob der Thread aktiv ist. public void yield(): bewirkt, dass das aktuell ausgeführte Thread-Objekt vorübergehend angehalten wird und die Ausführung anderer Threads ermöglicht wird. public void suspend(): wird verwendet, um den Thread anzuhalten (veraltet). öffentlicher leerer Lebenslauf(): wird verwendet, um den angehaltenen Thread fortzusetzen (veraltet). public void stop(): wird verwendet, um den Thread zu stoppen (veraltet). öffentlicher boolescher Wert isDaemon(): testet, ob der Thread ein Daemon-Thread ist. public void setDaemon(boolean b): Markiert den Thread als Daemon oder Benutzer-Thread. public void interrupt(): unterbricht den Thread. öffentlicher boolescher Wert isInterrupted(): testet, ob der Thread unterbrochen wurde. öffentlicher statischer boolescher Wert interrupted(): testet, ob der aktuelle Thread unterbrochen wurde.

Ausführbare Schnittstelle:

Die Runnable-Schnittstelle sollte von jeder Klasse implementiert werden, deren Instanzen von einem Thread ausgeführt werden sollen. Die ausführbare Schnittstelle verfügt nur über eine Methode namens run().

public void run(): wird verwendet, um eine Aktion für einen Thread auszuführen.

Einen Thread starten:

Der start()-Methode der Thread-Klasse wird verwendet, um einen neu erstellten Thread zu starten. Es übernimmt folgende Aufgaben:

• Ein neuer Thread startet (mit neuem Callstack).
• Der Thread wechselt vom Status „Neu“ in den Status „Ausführbar“.
• Wenn der Thread ausgeführt werden kann, wird seine Zielmethode run() ausgeführt.

1) Java-Thread-Beispiel durch Erweiterung der Thread-Klasse

Dateiname: Multi.java

 class Multi extends Thread{ public void run(){ System.out.println('thread is running...'); } public static void main(String args[]){ Multi t1=new Multi(); t1.start(); } }  

Ausgabe:

 thread is running...  

2) Java-Thread-Beispiel durch Implementierung der Runnable-Schnittstelle

Dateiname: Multi3.java

 class Multi3 implements Runnable{ public void run(){ System.out.println('thread is running...'); } public static void main(String args[]){ Multi3 m1=new Multi3(); Thread t1 =new Thread(m1); // Using the constructor Thread(Runnable r) t1.start(); } }  

Ausgabe:

 thread is running...  

Wenn Sie die Thread-Klasse nicht erweitern, wird Ihr Klassenobjekt nicht als Thread-Objekt behandelt. Daher müssen Sie das Thread-Klassenobjekt explizit erstellen. Wir übergeben das Objekt Ihrer Klasse, das Runnable implementiert, damit die run()-Methode Ihrer Klasse ausgeführt werden kann.

3) Verwendung der Thread-Klasse: Thread(String Name)

Wir können die Thread-Klasse direkt verwenden, um neue Threads mithilfe der oben definierten Konstruktoren zu erzeugen.

Dateiname: MyThread1.java

 public class MyThread1 { // Main method public static void main(String argvs[]) { // creating an object of the Thread class using the constructor Thread(String name) Thread t= new Thread('My first thread'); // the start() method moves the thread to the active state t.start(); // getting the thread name by invoking the getName() method String str = t.getName(); System.out.println(str); } }  

Ausgabe:

 My first thread  

4) Verwenden der Thread-Klasse: Thread(Runnable r, String name)

Beachten Sie das folgende Programm.

Dateiname: MyThread2.java

 public class MyThread2 implements Runnable { public void run() { System.out.println('Now the thread is running ...'); } // main method public static void main(String argvs[]) { // creating an object of the class MyThread2 Runnable r1 = new MyThread2(); // creating an object of the class Thread using Thread(Runnable r, String name) Thread th1 = new Thread(r1, 'My new thread'); // the start() method moves the thread to the active state th1.start(); // getting the thread name by invoking the getName() method String str = th1.getName(); System.out.println(str); } }  

Ausgabe:

 My new thread Now the thread is running ...