Vergleich der Thread-Implementierungsmethoden in Java und der Lambda-Ausdrucksmethode

Einführung

In Eile vom Arbeitsplatz aus, um ein Multithread-Programm mit Java zu erstellen Ich werde zusammenfassen, was ich in Eile gelernt habe, um unangemessene Anfragen zu beantworten.

• Die Java-Erfahrung beträgt noch ca. 3 Tage. Bitte weisen Sie darauf hin, wenn Sie einen Fehler machen.

Fazit: Wenn Sie vorerst schnell starten möchten

Wenn der Pfad zum Start des Subthreads klein ist und Sie den Subthread nicht als Instanz behalten möchten, kombinieren Sie Lambda-Ausdrücke

ThreadStartTemplate.java

new Thread( () -> {Methode oder Prozess, die Sie in einem Subthread ausführen möchten} ).start()

Sieht gut aus. Es ist bequem.

• Ich verstehe, dass der Lambda-Ausdruck eine lokale anonyme Klasse ist.

Ausführungsumgebung

Ich habe die Installation von Eclipse selbst verschoben und vorerst paiza.io verwendet, um die Grammatik zu überprüfen.

So implementieren Sie Subthreads

Es scheint, dass Threads mit den folgenden zwei Mustern implementiert werden können.

1. Verwenden Sie die Rnnable-Schnittstelle.
2. Erben Sie die Thread-Klasse.

1. Verwenden Sie die Runnable-Schnittstelle

Es scheint, dass Java eine Runnable-Schnittstelle hat, und durch Überschreiben von run () scheint es, dass die zum Zeitpunkt des Threads ausgeführte Verarbeitung implementiert werden kann. Die Verwendung ist wie folgt.

1. Erstellen Sie eine Instanz einer Klasse, die die Runnable-Schnittstelle implementiert
2. Übergeben Sie ein Runnnable-Objekt an den Konstruktor, um ein Thread-Objekt zu erstellen
3. Rufen Sie die start () -Methode der Thread-Klasse auf, um einen Unterfaden zu starten

Der gemäß dieser Straße geschriebene Beispielcode lautet RunnableSample.java.

RunnableSample.java

import java.util.*;

public class Main {
    
    private static class RunnableSample implements Runnable{
        
        private String thread_no;
        RunnableSample(String str){
            this.thread_no = str;
        }
        public void run(){
            System.out.println("RunnableThread Starting No."+thread_no);
        }
    }
    
    public static void main(String[] args) throws Exception {
        String str1 = "1";
        String str2 = "2";
        RunnableSample runner1 = new RunnableSample(str1); // 1.
        RunnableSample runner2 = new RunnableSample(str2); // 1.
        Thread thread1 = new Thread(runner1); // 2.
        Thread thread2 = new Thread(runner2); // 2.
        thread1.start(); // 3.
        thread2.start(); // 3.
        
        Thread.sleep(200);
        System.out.println("MainThread End");
    }
}

Ausführungsergebnis

RunnableThread Starting No.1
RunnableThread Starting No.2
MainThread End

Die RunnableSample-Klasse ist als lokale Klasse der Main-Klasse definiert. Erstellen Sie ein Objekt der RunnableSample-Klasse aus dem Hauptthread und führen Sie es als zwei Unterthemen aus.

RunnableThread Starting No.1 RunnableThread Starting No.2 Kann in umgekehrter Reihenfolge ausgegeben werden. Das Haupt-Thread-Ende wird normalerweise zuletzt ausgegeben, da dazwischen ein Ruhezustand von 200 ms liegt.

2. Erben Sie die Thread-Klasse.

Als nächstes werde ich darüber schreiben, wie die Thread-Klasse geerbt und die Subthread-Verarbeitung implementiert wird. Die Verwendung ist wie folgt. Der Code lautet ThreadSample.java.

1. Erstellen Sie eine Instanz der Klasse, die run () der Thread-Klasse überschreibt
2. Rufen Sie die start () -Methode der Thread-Klasse auf, um einen Unterfaden zu starten

ThreadSample.java

import java.util.*;

public class Main {
    
    private static class ThreadSample extends Thread{
        
        private String thread_no;
        ThreadSample(String str){
            this.thread_no = str;
        }
        public void run(){
            System.out.println("RunnableThread Starting No."+thread_no);
        }
    }
    
    public static void main(String[] args) throws Exception {

        String str1 = "1";
        String str2 = "2";
        ThreadSample thread1 = new ThreadSample(str1); // 1.
        ThreadSample thread2 = new ThreadSample(str2); // 1.
        thread1.start(); // 2.
        thread2.start(); // 2.
        
        Thread.sleep(200);
        System.out.println("MainThread End");
    }
}

Ausführungsergebnis

RunnableThread Starting No.2
RunnableThread Starting No.1
MainThread End

Das Ausführungsergebnis ist das gleiche (diesmal wurde die Ausgabereihenfolge von Thread1 und Thread2 umgekehrt).

Was ist besser, "Implementierung der Runnable-Schnittstelle" oder "Vererbung der Thread-Klasse"?

Grundsätzlich bietet die Verwendung der Runnable-Schnittstelle viele Vorteile.

• Java erlaubt keine Mehrfachvererbung. Wenn Sie also die Thread-Klasse erben, können andere Klassen sie nicht erben. Jede Klasse, die die Runnable-Schnittstelle implementiert, kann von anderen Klassen erben.
• Sie müssen den Overhead der Thread-Klasse nicht erben.
• Der Code scheint sauberer zu sein, wenn Sie die Thread-Klasse erben.

Es wäre perfekt, wenn ich es auch mit der Runnable-Oberfläche ordentlich schreiben könnte. Ich werde es versuchen.

Vereinfachen Sie die Beschreibung der Runnable-Schnittstelle mit Lambda-Ausdrücken.

Versuchen Sie, den Code mit Lambda-Ausdrücken zu vereinfachen, indem Sie auf Grundlegendes zu Java 8-Lambda-Ausdrücken verweisen.

LambdaThreadSample.java

import java.util.*;

public class Main {
    
    static private void subthread_run(String thread_no){
        System.out.println("RunnableThread Starting No."+thread_no);
    }
    
    public static void main(String[] args) throws Exception {

        String str1 = "1";
        String str2 = "2";
        new Thread( () -> {subthread_run(str1);} ).start();
        new Thread( () -> {subthread_run(str2);} ).start();
        
        Thread.sleep(200);
        System.out.println("MainThread End");
    }
}

Ausführungsergebnis

RunnableThread Starting No.2
RunnableThread Starting No.1
MainThread End

Die detaillierte Beschreibungsmethode finden Sie unter Grundlegendes zu Java 8 Lambda-Ausdrücken, aber ~~ schwer zu erklären ~~ Die RunnableSample-Klasse ist eine anonyme Klasse mit einer subthread_run-Methode, und das Thread-Klassenobjekt ist neu und gestartet. Durch die Verwendung der Lambda-Formel ist das Programm viel sauberer und lesbarer geworden. Dies ist eine gute Möglichkeit zum Schreiben, wenn Sie Thread nicht als Instanz verwalten müssen. Als nächstes möchte ich Synchronized zusammenfassen.

Verweise

150 Fragen zum Trainieren von Programmierkenntnissen für den Kampf in der Welt Kapitel 16: Thread und Lock