Erstellung und Start von Java-Multithreading

Threads werden in Java üblicherweise in drei Grundformen erstellt:

1. Erben Sie die Thread-Klasse und überschreiben Sie die run()-Methode dieser Klasse

Erben Sie die Thread-Klasse und überschreiben Sie die run()-Methode dieser Klasse

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0 ;i < 50;i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
    public static void main(String[] args) {
        for (int i = 0;i<50;i++) {
            //调用Thread类的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 10) {
                new MyThread().start();
                new MyThread().start(); 
            }
        }
    }
}

Laufendes Ergebnis:

...
main 48
main 49
Thread-0：0
Thread-0：1
Thread-0：2
Thread-0：3
Thread-0：4
Thread-1：0
...

Wie aus dem Ergebnis ersichtlich ist:

1. Es gibt drei Threads: main, Thread-0, Thread-1;

2 Der Wert der Mitgliedsvariablen i wird von den beiden Threads Thread-0 und Thread-1 ausgegeben kontinuierlich (hier handelt es sich eher um Instanzvariablen als um lokale Variablen). Denn: Bei der Implementierung von Multithreading durch Erben der Thread-Klasse erfordert die Erstellung jedes Threads die Erstellung eines anderen Unterklassenobjekts, was dazu führt, dass die beiden Threads Thread-0 und Thread-1 die Mitgliedsvariable i

< nicht gemeinsam nutzen 🎜>3. Die Ausführung des Threads erfolgt präventiv und es heißt nicht, dass Thread-0 oder Thread-1 immer die CPU belegen (dies hängt auch mit der Thread-Priorität zusammen. Hier haben Thread-0 und Thread-1 die gleiche Thread-Priorität. Informationen zur Thread-Priorität sind hier nicht verfügbar Klasse durch Implementierung der Runnable-Schnittstelle

Definieren Sie ein Instanzobjekt obj der Klasse; übergeben Sie obj als Konstruktorparameter an das Instanzobjekt der Thread-Klasse echtes Thread-Objekt.

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0 ;i < 50 ;i++) {
            System.out.println(Thread.currentThread().getName()+"：" +i);
        }
    }

    public static void main(String[] args) {
       for (int i = 0;i < 50;i++) {
            System.out.println(Thread.currentThread().getName() + "：" +i);
            if (i == 10) {
                MyRunnable myRunnable = new MyRunnable();
                new Thread(myRunnable).start();
                new Thread(myRunnable).start();
            }
        }
        //java8 labdam方式
         new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        },"线程3").start();
    }
}

Laufergebnisse:

...
main：46
main：47
main：48
main：49
Thread-0：28
Thread-0：29
Thread-0：30
Thread-1：30
...

1. Die von Thread 1 und Thread 2 ausgegebene Mitgliedsvariable i ist kontinuierlich, was bedeutet, dass durch die Erstellung von Threads auf diese Weise mehrere Threads Thread-Klassen gemeinsam nutzen können. Instanzvariablen, da hier mehrere Threads dieselbe Zielinstanzvariable verwenden. Wenn Sie jedoch den obigen Code ausführen, werden Sie feststellen, dass die Ergebnisse nicht kontinuierlich sind. Dies liegt daran, dass Thread-Sicherheitsprobleme auftreten, wenn mehrere Threads auf dieselbe Ressource zugreifen . Java8 kann die Lambda-Methode verwenden, um Multithreads zu erstellen.

3. Erstellen Sie Threads über Callable- und Future-Schnittstellen

Erstellen Sie eine Callable-Schnittstellen-Implementierungsklasse und implementieren Sie die call()-Methode, die als Thread-Ausführungskörper dient. und Die Methode hat einen Rückgabewert und erstellt dann eine Instanz der Callable-Implementierungsklasse. Verwenden Sie die FutureTask-Klasse, um das Callable-Objekt zu kapseln, das den Rückgabewert der call()-Methode des Callable-Objekts kapselt als Ziel des Thread-Objekts, um einen neuen Thread zu erstellen und zu starten; rufen Sie die get()-Methode des FutureTask-Objekts auf, um den Rückgabewert zu erhalten, nachdem die Ausführung des untergeordneten Threads beendet ist. Der Rückgabewerttyp der

public class MyCallable implements Callable<Integer> {
    private int i = 0;
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建MyCallable对象
        Callable<Integer> myCallable = new MyCallable();
        //使用FutureTask来包装MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable);
        for (int i = 0;i<50;i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            if (i == 30) {
                Thread thread = new Thread(ft);
                thread.start();
            }
        }
        System.out.println("主线程for循环执行完毕..");
        Integer integer = ft.get();
        System.out.println("sum = "+ integer);
    }
}

call()-Methode stimmt mit dem Typ in <> überein, als das FutureTask-Objekt erstellt wurde.

Empfohlene verwandte Tutorials:

Java Quick Start

Das obige ist der detaillierte Inhalt vonErstellung und Start von Java-Multithreading. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!