Welche Möglichkeiten gibt es, Threads in Java zu erstellen? Drei Möglichkeiten zum Erstellen von Threads in Java

In diesem Artikel erfahren Sie, welche Möglichkeiten es gibt, Threads in Java zu erstellen. Die drei Möglichkeiten, Threads in Java zu erstellen, haben einen gewissen Referenzwert. Ich hoffe, dass sie für Sie hilfreich sind.

1. Erben Sie die zu erstellende Thread-Klasse.

Durch das Erben von Thread und das Umschreiben seiner run() führt der Thread die Aufgabe in der run-Methode aus. Die erstellte Unterklasse kann Thread-Methoden ausführen, indem sie die Methode start() aufruft.

Durch die Erbung der von Thread implementierten Thread-Klasse können mehrere Threads die Instanzvariablen der Thread-Klasse nicht gemeinsam nutzen. (Es müssen verschiedene Thread-Objekte erstellt werden, die natürlich nicht geteilt werden)

Beispiel:

/**
 * 通过继承Thread实现线程
 */
public class ThreadTest extends Thread{
　　
　　private int i = 0 ;

    @Override
    public void run() {
        for(;i<50;i++){
            System.out.println(Thread.currentThread().getName() + " is running " + i );
        }
    }

    public static void main(String[] args) {
        for(int j=0;j<50;j++){if(j=20){
                new ThreadTest().start() ;
                new ThreadTest().start() ;
            }
        }
    }
}

2. Erstellen Sie eine Thread-Klasse über Runnable Schnittstelle

Diese Methode muss zuerst eine Klasse definieren, um die Runnable-Schnittstelle zu implementieren und die run()-Methode der Schnittstelle zu überschreiben. Diese Ausführungsmethode ist der Thread-Ausführungskörper. Erstellen Sie dann ein Objekt der Runnable-Implementierungsklasse als Parameterziel für die Erstellung des Thread-Objekts Dieses Thread-Objekt ist das eigentliche Thread-Objekt. Thread-Klassen, die die Runnable-Schnittstelle implementieren, teilen Ressourcen miteinander.

/**
 * 通过实现Runnable接口实现的线程类
 */
public class RunnableTest implements Runnable {
    private int i ;
    @Override
    public void run() {
        for(;i<50;i++){
            System.out.println(Thread.currentThread().getName() + " -- " + i);
        }
    }
    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName() + " -- " + i);
            if(i==20){
                RunnableTest runnableTest = new RunnableTest() ;
                new Thread(runnableTest,"线程1").start() ;
                new Thread(runnableTest,"线程2").start() ;
            }
        }
    }
}

3. Verwenden Sie Callable und Future, um Threads zu erstellen

Wie aus der Vererbung der Thread-Klasse und der Implementierung von Runnable hervorgeht Schnittstelle, die beiden oben genannten Keine dieser Methoden kann einen Rückgabewert haben und kann nicht zum Auslösen einer Ausnahme deklariert werden. Die Callable-Schnittstelle implementiert diese beiden Punkte. Die Callable-Schnittstelle ist wie eine aktualisierte Version der Runable-Schnittstelle. Die von ihr bereitgestellte call()-Methode dient als Ausführungskörper des Threads und ermöglicht einen Rückgabewert.

Das Callable-Objekt kann jedoch nicht direkt als Ziel des Thread-Objekts verwendet werden, da die Callable-Schnittstelle eine neue Schnittstelle in Java 5 und keine Unterschnittstelle der Runnable-Schnittstelle ist. Die Lösung für dieses Problem besteht darin, die Future-Schnittstelle einzuführen, die den Rückgabewert von call() akzeptieren kann. Die Future-Schnittstelle ist eine Unterschnittstelle der Runnable-Schnittstelle und kann als Ziel des Thread-Objekts verwendet werden. Darüber hinaus stellt die Future-Schnittstelle eine Implementierungsklasse bereit: FutureTask.

FutureTask implementiert die Future-Schnittstelle und die Runnable-Schnittstelle und kann als Ziel des Thread-Objekts verwendet werden.

Die Beziehung ist wie folgt:

　

Beispiel:

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class CallableTest {
    public static void main(String[] args) {
        CallableTest callableTest = new CallableTest() ;
        //因为Callable接口是函数式接口，可以使用Lambda表达式
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
           int i = 0 ;
           for(;i<100;i++){
               System.out.println(Thread.currentThread().getName() + "的循环变量i的值 ：" + i);
           }
           return i;
        });
       for(int i=0;i<100;i++){
           System.out.println(Thread.currentThread().getName()+" 的循环变量i ： + i");
           if(i==20){
               new Thread(task,"有返回值的线程").start();
           }
       }
       try{
           System.out.println("子线程返回值 ： " + task.get());
        }catch (Exception e){
           e.printStackTrace();
        }
    }
}

Zusammenfassung

Durch die oben genannten drei Methoden können sie tatsächlich in zwei Kategorien eingeteilt werden: Klassen erben und Schnittstellen implementieren. Im Vergleich zur Vererbung kann die Schnittstellenimplementierung flexibler sein und wird nicht durch den einzelnen Vererbungsmechanismus von Java eingeschränkt. Und Ressourcen können durch die Implementierung von Schnittstellen gemeinsam genutzt werden, was für Multithreads geeignet ist, die dieselbe Ressource verarbeiten. Das Thread-Wissen ist umfangreich und kompliziert, und es müssen weitere Details erlernt und beherrscht werden.

Das obige ist der detaillierte Inhalt vonWelche Möglichkeiten gibt es, Threads in Java zu erstellen? Drei Möglichkeiten zum Erstellen von Threads in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!