Der Inhalt dieses Artikels befasst sich mit der Frage, wie man Multithreading in Java erstellt. (ausführlich), es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen.
Ein Thread ist eine Einheit im Prozess und die Grundeinheit, die vom System unabhängig geplant und versendet wird keine eigenen Systemressourcen, sondern nur eine unverzichtbare Ressource während des Betriebs, aber es kann alle Ressourcen, die dem Prozess gehören, mit anderen Threads teilen, die zum selben Prozess gehören
Oberflächlich betrachtet ist es multi- Threading, aber tatsächlich wechselt sich die CPU ab, um schnell auszuführen
Parallel: Zwei Aufgaben werden gleichzeitig ausgeführt, Das heißt, während Aufgabe A ausgeführt wird, wird auch Aufgabe B ausgeführt (erfordert mehrere Kerne)
Gleichzeitigkeit: Beide Aufgaben werden zur Ausführung aufgefordert, und der Prozessor kann daher nur eine Aufgabe annehmen Die beiden Aufgaben sollen nacheinander ausgeführt werden. Da das Zeitintervall sehr kurz ist, haben die Leute das Gefühl, dass beide Aufgaben ausgeführt werden
Der Java-Befehl wird ausgeführt Starten Sie die JVM, was dem Starten einer Anwendung (eines Prozesses) entspricht. Der Prozess startet automatisch den „Hauptthread“. Der Hauptthread ruft die Hauptmethode
Nein, es ist Multi-Threaded. Zumindest werden der Garbage-Collection-Thread und der Haupt-Thread gestartet.
Dies kann durch den folgenden Code überprüft werden. Der Haupt-Thread und der Garbage-Collection-Thread konkurrieren um Ressourcen.
public class TestThread {
public static void main(String[] args) {
//4.创建Thread的子类对象
MyThread myThread = new MyThread();
//5.启动线程，注意这里使用的是start而不是run方法
myThread.start();
for (int i = 0; i < 10000; i ++) {
System.out.println("This is main thread");
}
}
}
//1.继承Thread
class MyThread extends Thread{
//2.重写run方法
@Override
public void run() {
super.run();
//3.线程方法中要执行的代码，可以根据自己的需求填写
for(int i = 0 ; i < 10000 ; i ++ ) {
System.out.println("This is MyThread thread ");
}
}
}Thread implementiert die Runnable-Schnittstelle
Um Multithreading zu implementieren, müssen Sie muss eine Unterklasse von Thread werden und die Ausführungsmethode überschreiben. Beachten Sie, dass beim Starten eines Threads nicht die Ausführungsmethode, sondern die Startmethode aufgerufen wird. Wenn die run-Methode aufgerufen wird, entspricht sie einer normalen Methode und öffnet den Thread nicht
public class Thread implements Runnable
public class TestThread {
public static void main(String[] args) {
MyThread myThread = new MyThread();
//注意这里使用的是start而不是run方法
myThread.start();
for (int i = 0; i < 10000; i ++) {
System.out.println("This is main thread");
}
}
}
class MyThread extends Thread{
@Override
public void run() {
super.run();
for(int i = 0 ; i < 10000 ; i ++ ) {
System.out.println("This is MyThread thread ");
}
}
}Es gibt nur eine Methode in Runnable, run(), Die Thread-Startmethode existiert in Thread,
Wenn wir dann endlich den Thread starten, müssen wir den Thread über das Unterklassenobjekt von Thread starten
public class TestRunnable {
public static void main(String[] args) {
//4.创建Thread的子类对象
Runnable myRunnable = new MyRunnable();
//5.启动线程,创建Thread并把runnable的子类作为构造参数
new Thread(myRunnable).start();
for (int i = 0; i < 10000; i ++) {
System.out.println("This is main thread");
}
}
}
//1.实现runnable接口
class MyRunnable implements Runnable {
//2.重写run方法
@Override
public void run() {
//3.线程方法中要执行的代码，可以根据自己的需求填写
for(int i = 0 ; i < 10000 ; i ++ ) {
System.out.println("This is MyRunnable thread ");
}
}
}Um Threads zu implementieren, können Sie zusätzlich zum Erben von Thread und Runnable auch die Callable-Schnittstelle implementieren. Die Callable-Schnittstelle bietet eine call()-Methode, die als Thread-Ausführungskörper verwendet werden kann und dieselbe Funktion wie run() hat. Die Methode call() hat jedoch mehr Rückgabewerte als die Methode run(), und die Methode call() kann die ausgelöste Ausnahme deklarieren. Wie starten wir also den Callable-Thread? Da die Callable-Schnittstelle keine Unterschnittstelle der Runnable-Schnittstelle ist, kann das Callable-Objekt nicht als Konstruktionsparameter von Thread verwendet werden. Java bietet eine weitere Schnittstelle, die RunnableFuture-Schnittstelle, die Runnable implementiert, Future
implementiert die Callable-Schnittstelle
Schreiben Sie die call-Methode, die der run-Methode im Thread entspricht. Der Unterschied besteht darin, dass die Aufrufmethode Rückgabewerte
ermöglicht, um das Callable-Implementierungsklassenobjekt als Konstruktionsparameter an FutureTask zu übergeben und so ein FutureTask-Objekt zu erstellen.
Übergeben Sie das FutureTask-Objekt als Konstruktionsparameter an Thread und starten Sie den Thread
public class CallableDemo {
public static void main(String[] args) {
//3.把Callable实现类对象作为构造参数传入FutureTask创建FutureTask对象。
FutureTask<UUID> futureTask = new FutureTask<UUID>(new MyCallable());
//4.把FutureTask对象作为构造参数传入Thread，并开启线程
new Thread(futureTask).start();
try {
System.out.println(futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1. 实现**Callable**接口
class MyCallable implements Callable<UUID> {
//2.重写**call**方法，相当于thread中的run方法。不同的是call方法允许有返回值
@Override
public UUID call() throws Exception {
//生成随机数
return UUID.randomUUID();
}
}Die Unterklasse schreibt die run()-Methode in Thread neu und ruft die start()-Methode auf. Der JVM ruft automatisch den Lauf der Unterklasse auf ()
new Thread(myRunnable) Geben Sie die Referenz von runnable in den Konstruktor von Thread ein und übergeben Sie sie dann an das Mitgliedsvariablenziel von Thread. In der Thread run()-Methode wird beurteilt, dass die Ausführungsmethode der Unterklasse aufgerufen wird, wenn das Ziel nicht leer ist.
public void run() {
if (this.target != null) {
this.target.run();
}implementiert die Callable-Schnittstelle und schreibt neu die Call()-Methode und kann Thread-Rückgabewerte bereitstellen und auch Ausnahmen auslösen. Schließlich wird es über die Implementierungsklasse FutureTask der Runnable-Subschnittstelle RunnableFuture an das Mitgliedsvariablenziel von Thread übergeben.
Vorteile: Rufen Sie die start()-Methode direkt im Thread auf, sehr einfach
Nachteile: Java unterstützt nur die Einzelvererbung. Wenn eine Unterklasse Threads erbt, kann sie keine anderen Klassen erben
Vorteile: Java kann mehrere implementieren
Nachteile: Das Schreiben des Codes ist kompliziert und start() kann nicht direkt
Vorteile: Java kann auf verschiedene Arten implementiert werden, kann Ausnahmen auslösen und Rückgabewerte haben
Nachteile: Das Schreiben von Code ist kompliziert
Das obige ist der detaillierte Inhalt vonWie erstelle ich Multithreading in Java? (ausführlich). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
