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.
Was ist ein Thread:
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
Multi-Threading (parallel und gleichzeitig)
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
Multithreading (das Prinzip der Ausführung von Java-Programmen)
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
auf. Ist es ein Single-Thread, um den JVM zu starten?
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 ");
}
}
}Nach dem Login kopieren
So erstellen Sie Multithreads in Java
(1) Erben Sie die Thread-Klasse und rufen Sie die Startmethode auf
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
Nach dem Login kopieren
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 ");
}
}
}Nach dem Login kopieren
(2) Implementieren Sie die ausführbare Schnittstelle und schreiben Sie die run-Methode neu
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 ");
}
}
}Nach dem Login kopieren
die Callable-Schnittstelle implementieren
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();
}
}Nach dem Login kopieren
Thread erben, um den Unterschied zwischen Runnable und Callable zu erkennen
Aus der Quellcode-Implementierung
Thread erben
Die Unterklasse schreibt die run()-Methode in Thread neu und ruft die start()-Methode auf. Der JVM ruft automatisch den Lauf der Unterklasse auf ()
Implement Runnable
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();
}Nach dem Login kopieren
implementiert die Callable-Schnittstelle
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.
In Bezug auf Verwendung und Erweiterung
Thread erben
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
Runnable implementieren
-
Vorteile: Java kann mehrere implementieren
Nachteile: Das Schreiben des Codes ist kompliziert und start() kann nicht direkt
zur Implementierung aufgerufen werden Aufrufbar
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!
