So implementieren Sie Java-Multithreading

So implementieren Sie Java-Multithreading

Java-Multithreading ist eine der erweiterten Funktionen von Java. Durch Multithreading können wir gleichzeitig Multitasking und Zusammenarbeit realisieren und unter bestimmten Umständen die Programmeffizienz verbessern. Java-Multithreading muss jedoch zunächst mit Vorsicht angewendet werden Hohe Programmierkenntnisse führen bei unsachgemäßer Verwendung zu Programmfehlern und böswilligen Threads zum Einfrieren des Programms. Zweitens kann der Missbrauch von Multithreading dazu führen, dass einige Schlüsselparameter gestört werden. In diesem Fall müssen Synchronisierung und Sperrenverwaltung zwischen Threads durchgeführt werden. Drittens verursacht der Thread-Wechsel zusätzliche Kosten, was oft als „Kontextwechsel“ bezeichnet wird. Bei unsachgemäßer Verwendung wird die Effizienz nicht nur nicht verbessert, sondern führt auch zu einem starken Effizienzverlust. (Empfohlenes Tutorial: Java-Tutorial)

1. Thread erben, um Multithreading zu implementieren

Java bietet einen Super-Klassen-Thread, den wir erweitern können Sobald Sie es geerbt haben, können Sie Multithreading implementieren, indem Sie die Ausführungsmethode überschreiben. Der spezifische Code lautet wie folgt:

import java.io.*;
 
public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
 
    public static void main(String[] args) throws IOException {
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        t1.start();
        t2.start();
    }
}

2. Durch die Implementierung der Runnable-Schnittstelle 🎜 >Da einige Klassen Thread nicht erben können, um Multithreading zu implementieren, da Java vorschreibt, dass nur eine Superklasse gleichzeitig geerbt werden kann, aber mehrere Schnittstellen gleichzeitig implementieren können, ist Runnable noch beliebter . Der spezifische Code lautet wie folgt:

import java.io.*;
 
public class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
 
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread(new MyThread());
        Thread t2 = new Thread(new MyThread());
        t1.start();
        t2.start();
    }
}

Die obige Methode definiert direkt die Klasse zum Implementieren der Runnable-Methode. Tatsächlich kann sie auch wie folgt in eine anonyme innere Klassenmethode umgewandelt werden, um einen Thread zu erstellen:

import java.io.*;
 
public class MyThread {
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId());
            }
        });
 
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId());
            }
        });
 
        t1.start();
        t2.start();
    }
}

3. Implementieren Sie einen Thread über Callable

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
 
public class MyThread implements Callable<Integer>{
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        FutureTask<Integer> future = new FutureTask<Integer>(t1);
        new Thread(future,"呵呵哒").start();
    }
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return null;
    }
}

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