Kürzlich habe ich die Verwendung von Java Multi-Threading bei der Codeoptimierung gelernt und untersucht und sie dann nach dem Lesen der Erkenntnisse der Anfänger zusammengefasst.
1. Erben Sie die Thread-Klasse, um Multi-Threading zu implementieren
Obwohl die Methode, die die Thread-Klasse erbt, als Multi-Thread-Implementierungsmethode aufgeführt ist, ist Thread im Wesentlichen eine Instanz der Runnable-Schnittstelle, die eine Instanz eines Threads darstellt, und die einzige Möglichkeit, einen Thread zu starten, ist die Start () Instanzmethode der Thread-Klasse. Die Start () -Methode ist eine native Methode, die einen neuen Thread startet und die Run () -Methode ausführt. Diese Methode ist sehr einfach zu implementieren Multi-Threading. Indem Sie den Thread direkt durch Ihre eigene Klasse erweitern und die Run () -Methode neu schreiben, können Sie einen neuen Thread starten und die von Ihnen definierte Run () -Methode ausführen. Zum Beispiel:
öffentliche Klasse MyThread erweitert Thread {public void run () {System.out.println ("mythead.run ()"); }} Starten Sie den Thread wie folgt an der richtigen Stelle:
MyThread myThread1 = new MyThread (); MyThread myThread2 = new MyThread (); myThread1.Start (); MyThread2.Start ();
2. Implementieren Sie die Runnable-Schnittstelle, um Multi-Threading zu implementieren
Wenn Ihre Klasse bereits eine andere Klasse erweitert, können Sie Thread nicht direkt erweitern. Zu diesem Zeitpunkt müssen Sie wie folgt eine runnable Schnittstelle implementieren:
public class myThread erweitert andere Class implementiert Runnable {public void run () {System.out.println ("myThread.run ()"); }} Um MyThread zu starten, müssen Sie zuerst einen Thread instanziieren und in Ihrer eigenen MyThread -Instanz übergeben:
MyThread MyThread = New MyThread (); Thread = neuer Thread (MyThread); Thread.Start ();
Wenn ein Runnable -Zielparameter an Thread übergeben wird, wird die Thread -Methode run () tat target.run () auf den JDK -Quellcode aufgerufen:
public void run () {if (target! = null) {target.run (); }} 3.. Verwenden Sie Executorservice, Callable und Future, um Multi-Threading mit Rückgabebereichern zu erreichen
Executorservice, Callable und Future Objects sind tatsächlich Funktionsklassen im Ausführungsrahmen. Dies ist eine sehr detaillierte Erklärung des Rahmens. Der Thread, der das Ergebnis zurückgibt, ist eine neue Funktion, die in JDK1.5 eingeführt wird. Es ist in der Tat sehr praktisch. Mit dieser Funktion muss ich keine großen Probleme durchführen, um den Rückgabewert zu erhalten, und selbst wenn er implementiert ist, ist es möglicherweise voller Lücken.
Aufgaben, die Werte zurückgeben können, müssen die Callable -Schnittstelle implementieren, und ähnlich müssen Aufgaben, die keine Rückgabewerte zurückgeben, die Runnable -Schnittstelle haben. Nachdem Sie die Callable -Aufgabe ausgeführt haben, können Sie ein zukünftiges Objekt erhalten. Rufen Sie das Objekt an, um das von der Aufgabe zurückgegebene Objekt zurückzugeben. In Kombination mit dem Ausführenden der Thread Pool-Schnittstelle können Sie das legendäre Multi-Threading mit dem Rückgabeergebnis erkennen. Im Folgenden finden Sie ein komplettes Beispiel für Multi-Thread-Tests mit zurückgegebenen Ergebnissen. Wenn Sie es unter JDK1.5 überprüft haben, können Sie es direkt verwenden. Der Code ist wie folgt:
import Java.util.Concurrent.*; import Java.util.date; importieren java.util.list; Import Java.util.ArrayList; / *** Thread mit Rückgabewert*/ @Suppresswarnings ("Deaktiviert") öffentlicher Klassen -Test {public static void main (String [] args) löst ExecutionException, InterruptedException {aus System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Pool = Executors. System.out.println (">>>" + f.get (). ToString ()); // Erhalten Sie die laufenden Ergebnisse aller gleichzeitigen Aufgaben für (Future F: List) {// den Rückgabewert der Aufgabe aus dem zukünftigen Objekt abrufen und an das Konsolensystem ausgeben. } Datum Datum2 = neues Datum (); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- MyCallable (String taskNum) {thas.tasknum = tasknum; System.out.println (">>>" + Tasknum + "Task -Termination"); Code Beschreibung:
Im obigen Code bietet die Ausführungsklasse eine Reihe von Werksmethoden zum Erstellen des Thread -Pools, und die zurückgegebenen Thread -Pools implementieren alle die ExecutorService -Schnittstelle.
öffentlicher statischer Executorservice Newfixed threadpool (int nthreads)
Erstellt einen Thread -Pool mit einer festen Anzahl von Threads.
öffentlicher statischer Executorservice NewcachedThreadpool ()
Erstellen Sie einen zwischengespeicherbaren Thread -Pool. Durch das Aufrufen von Execute werden zuvor konstruierte Threads wiederverwendet (falls der Thread verfügbar ist). Wenn der vorhandene Thread nicht verfügbar ist, erstellen Sie einen neuen Thread und fügen Sie ihn dem Pool hinzu. Beenden und entfernen Sie die Fäden aus dem Cache, die 60 Sekunden lang nicht verwendet wurden.
öffentlicher statischer Executorservice NewsingLethreadExecutor ()
Erstellen Sie einen Einzelzeugen mit einem Thread.
Öffentliche statische ScheduledexecutorService Newsschoned threadpool (int corepoolsize)
Erstellen Sie einen Thread -Pool, der zeitgesteuerte und regelmäßige Aufgabenausführung unterstützt, die in den meisten Fällen anstelle der Timer -Klasse verwendet werden kann.
ExecutoreService stellt die methode submit () bereit, überholt eine aufrufbare oder laufbare und zurückkehrende Zukunft. Wenn der Hintergrund -Thread -Pool ausführender Thread die Berechnung der Callable nicht abgeschlossen hat, gibt dieser Aufruf die Get () -Methode des zukünftigen Objekts zurück, die bis zur Fertigstellung der Berechnung blockiert wird.