So verstehen Sie Threads in Java

Thread ist ein Ausführungspfad innerhalb eines Programms. Die uns bekannte Hauptmethode ist tatsächlich ein separater Ausführungspfad. dann Dieses Programm ist ein Single-Thread-Programm; da es einen Single-Thread gibt, wird es auch Multi-Threading geben. Die wörtliche Bedeutung kann als „eine Technologie, die mehrere Ausführungsprozesse auf Software und Hardware relativ zu einem Single-Threading verwendet“ verstanden werden. Thread". Die Vorteile von Multithreading sind #🎜🎜 #Verbesserung der CPU-Auslastung. Wenn in einem Multithread-Programm ein Thread warten muss, kann die CPU andere Threads ausführen, anstatt zu warten, was die Effizienz des Programms erheblich verbessert.

Erstellung von Multi-Threads

Methode 1: Thread-Klasse erben

Methode 1 Erstellungsprozess:

#🎜 🎜 #

Definieren Sie eine Unterklasse MyThread, um die Thread-Klasse java.lang.Thread zu erben und die run()-Methode zu überschreiben;
Erstellen Sie ein Objekt von MyThread Klasse; #🎜 🎜#

• Rufen Sie die start()-Methode des Thread-Objekts auf, um den Thread zu starten (die run()-Methode wird nach dem Start weiterhin ausgeführt);
• #🎜 🎜#Im obigen Code werden zwei Threads ausgeführt, nämlich der Hauptthread der Hauptmethode und der Unterthread, der durch Aufruf von start() für das Threadobjekt mythread gestartet wird. Aber warum ist das Ausgabeergebnis nicht eindeutig? Der Grund dafür ist, dass während der Ausführung eine CPU-Präemption zwischen den beiden Threads stattfindet und derjenige, der sie zuerst nutzt, zuerst ausgeführt wird.

• Warum verwenden wir also nicht direkt das Thread-Objekt, um die run()-Methode aufzurufen? Wenn run() direkt aufgerufen wird, handelt es sich nur um eine normale Aufrufmethode, also um einen einzelnen Thread, während die start()-Methode zum Starten untergeordneter Threads verwendet wird, sodass Multithreading auftreten kann.
  Vor- und Nachteile der ersten Methode:

Vorteile: einfache Codierung;

#🎜 🎜# Nachteile: Die Thread-Klasse hat Thread geerbt und kann keine anderen Klassen erben, was der Erweiterung nicht förderlich ist; Prozess:

• 1 Definieren Sie eine Thread-Task-Klasse MyRunnable, um die Runnable-Schnittstelle zu implementieren und die Ausführung zu überschreiben () Methode;

2 Erstellen Sie ein MyRunnable-Objekt;
• #🎜🎜 #3. Rufen Sie die start()-Methode des Thread-Objekts auf, um den Thread zu starten.

öffentlicher Thread (String-Name)

kann für den aktuellen Thread-Namen angegeben werden

öffentlicher Thread (ausführbares Ziel)

Kapseln Sie das ausführbare Objekt, um ein Thread-Objekt zu werden

# 🎜🎜#öffentlicher Thread (ausführbares Ziel, String-Name)#🎜 🎜#

Kapseln Sie das ausführbare Objekt als Thread-Objekt und geben Sie den Thread-Namen an Das MyRunnable-Aufgabenobjekt muss in Thread gekapselt werden. Die anderen Stellen bleiben grundsätzlich unverändert.

Vor- und Nachteile der zweiten Methode: Vorteile: Die Thread-Task-Klasse implementiert nur die Schnittstelle und kann die Klasse weiterhin erben und die Schnittstelle implementieren und verfügt über eine starke Skalierbarkeit ; Nachteile: Die Programmierung erfordert eine zusätzliche Ebene der Objektverpackung. Wenn der Thread Ausführungsergebnisse hat, kann er nicht direkt zurückgegeben werden. Als nächstes verwenden wir auch die Runnable-Schnittstelle (anonyme innere Klassenform), um die Erstellung von Multithreads zu erreichen: 1 Erstellen Sie ein ausführbares anonymes inneres Klassenobjekt #🎜 🎜# Methode 3: Implementieren Sie die Callable-Schnittstelle1 Definieren Sie eine Klasse, um die Callable-Schnittstelle zu implementieren, überschreiben Sie die call()-Methode und kapseln Sie, was getan werden muss 🎜# 2. Kapseln Sie das Callable-Objekt in ein Thread-Aufgabenobjekt. 3. Übergeben Sie das Thread-Aufgabenobjekt zur Verarbeitung . Rufen Sie die start()-Methode von Thread auf, um die Aufgabe auszuführen. Nachdem die Thread-Ausführung abgeschlossen ist, erhalten Sie das Ergebnis der Aufgabenausführung über die get()-Methode von FutureTask.

2. Überlassen Sie es Thread zur Verarbeitung.	3 Der große Unterschied besteht darin, dass ein Thread-Objekt erstellt werden muss. während die andere Multithreading durch anonyme innere Klassen ist. Und dieser Codeblock kann auch durch Lambda-Ausdrücke optimiert werden. Ich frage mich, ob Sie von diesem Wissenspunkt immer noch beeindruckt sind. Wenn Sie es vergessen haben, können Sie diesen Artikel lesen: So verstehen Sie Lambda-Ausdrücke in Java – Vereinfachung
Nachdem Sie die beiden vorherigen Kreationen gelernt haben. Nach der Verwendung Bei der Multithreading-Methode werden wir feststellen, dass ein Problem vorliegt: 1. Die neu geschriebene run()-Methode kann keine Ergebnisse direkt zurückgeben. 2. Sie ist nicht für Geschäftsszenarien geeignet, die Thread-Ausführungsergebnisse zurückgeben müssen. Deshalb brauchen wir einen dritten Weg, um diese Probleme zu lösen.	Erstellungsprozess der dritten Methode:

Methodenname

Beschreibung

public. FutureTask< ; >(Callable-Aufruf)

Kapseln Sie das Callable-Objekt in ein FutureTask-Objekt

public V get() löst eine Ausnahme aus

# 🎜 🎜#Erhalten Sie das Ergebnis, das vom Thread zurückgegeben wird, der die Aufrufmethode ausführt

public class ThreadDemo03 {
    public static void main(String[] args) throws Exception {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        int sum= 0;
        for (int i = 0; i < 3; i++) {
            sum+=i;
        }
        System.out.println(sum);
        String s =futureTask.get();
        System.out.println(s);
    }
}
class MyCallable implements Callable<String > {
    @Override
    public String call(){
        int sum=0;
        for (int i = 0; i < 3; i++) {
            sum+=i;
        }
        return "子线程计算结果："+sum;
    }
}
//输出结果：
//3
//子线程计算结果：3

方式三优缺点：

优点：

线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；

可以在线程执行完毕后去获取 线程执行的结果；

缺点：

编码复杂一点；

总结

方式	优点	缺点
继承Thread类	编程比较简单，可以直接使用Thread类中的方法	扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口	扩展性强，实现该接口的同时还可以继承其他的类	编程相对复杂，不能返回线程执行的结果
实现Callable接口	扩展性强，实现该接口的同时还可以继承其他的类，可以得到线程的执行结果	编程相对复杂

常用方法

Thread获取和设置线程名称

方法名称	说明
String getName()	获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name)	将此线程更改为指定的名称，通过构造器也可以设置线程名称

简单地通过一段代码让大家能够清晰地了解这个代码该如何使用：

public class ThreadDemo04 {
    public static void main(String[] args) throws Exception {
        thread thread1 = new thread();
        thread1.setName("1号子线程");
        thread1.start();
        thread thread2 = new thread();
        thread2.setName("2号子线程");
        thread2.start();
    }
}
class thread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(this.getName()+"正在执行任务"+i);
        }
    }
}
//输出结果：
//2号子线程正在执行任务0
//1号子线程正在执行任务0
//2号子线程正在执行任务1
//1号子线程正在执行任务1
//2号子线程正在执行任务2
//1号子线程正在执行任务2

Thread类的线程休眠方法

方法名称	说明
public static void sleep(long time)	让当前线程休眠指定的时间后再继续执行，单位为毫秒

public class ThreadDemo05 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
            if (i==3){
                Thread.sleep(5000);
            }
        }
    }
}
//输出结果：
//1
//2
//3
//在输出过3以后，等待5秒之后再进行输出
//4

Das obige ist der detaillierte Inhalt vonSo verstehen Sie Threads in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!