Wie erstelle ich Multithreading in Java? (ausführlich)

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)

1. 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)

2. 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 ");
        }
    }
}

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

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 ");
        }
    }
}

(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 ");
        }
    }
}

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

1. implementiert die Callable-Schnittstelle

2. Schreiben Sie die call-Methode, die der run-Methode im Thread entspricht. Der Unterschied besteht darin, dass die Aufrufmethode Rückgabewerte

3. ermöglicht, um das Callable-Implementierungsklassenobjekt als Konstruktionsparameter an FutureTask zu übergeben und so ein FutureTask-Objekt zu erstellen.

4. Ü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();
    }
}

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();
    }

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

1. Vorteile: Rufen Sie die start()-Methode direkt im Thread auf, sehr einfach

2. Nachteile: Java unterstützt nur die Einzelvererbung. Wenn eine Unterklasse Threads erbt, kann sie keine anderen Klassen erben

Runnable implementieren

1. Vorteile: Java kann mehrere implementieren

2. Nachteile: Das Schreiben des Codes ist kompliziert und start() kann nicht direkt

zur Implementierung aufgerufen werden Aufrufbar

1. Vorteile: Java kann auf verschiedene Arten implementiert werden, kann Ausnahmen auslösen und Rückgabewerte haben

2. 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!