Die Codekopie lautet wie folgt:
Paket com.yao;
import Java.util.concurrent.callable;
import Java.util.concurrent.executionException;
import Java.util.concurrent.executorService;
import Java.util.concurrent.executors;
import Java.util.concurrent.future;
Import Java.util.Concurrent.ScheduledexecutorService;
Import Java.util.Concurrent.TimeUnit;
/**
* Neue Aufgabenausführungsarchitektur.
* Vor Java 5.0 wurde eine Aufgabe mit dem Aufrufen der Start () -Methode der Thread -Klasse gestartet.
* Die Einreichung und Ausführung von Aufgaben werden gleichzeitig durchgeführt.
* Oder steuern Sie die Anzahl der gleichzeitig ausgeführten Threads, die zusätzlichen Code abgeschlossen werden müssen.
* 5.0 bietet eine neue Architektur für Aufgabenausführungen, mit der Sie die Ausführung von Aufgaben problemlos planen und steuern können.
* Und ein Threadpool, der einem Datenbankverbindungspool ähnelt, kann so eingerichtet werden, dass sie Aufgaben ausführen.
* Diese Architektur besteht hauptsächlich aus drei Schnittstellen und ihren entsprechenden spezifischen Klassen.
*Diese drei Schnittstellen sind Executor, Executorservice und ScheduledexecutorService.
* (1) Ausführungsschnittstelle: Wird verwendet, um ausgeführte Aufgaben auszuführen. Sie definiert nur eine Methode:
* Führen Sie aus (Runnable -Befehl): Führen Sie ruannable Typaufgaben aus
* (2) ExecutorService: Erbt die Ausführungsmethode und bietet Dienste zur Ausführung von Aufgaben und Ausführung von Aufgaben.
* Die Hauptmethoden seiner Definition sind:
* Senden (Aufgabe): Kann verwendet werden, um Callable- oder Runnable -Aufgaben einzureichen und das zukünftige Objekt zurückzugeben, das diese Aufgabe darstellt
* InvokeAll (Sammlung von Aufgaben): Stapelsammlung von Aufgaben und Rückgabe einer Sammlung zukünftiger Objekte, die diese Aufgaben darstellen.
* Shutdown (): Schließen Sie den Dienst nach Abschluss der eingereichten Aufgabe und akzeptiert keine neuen Aufgaben mehr.
* stilldownnow (): stoppt alle ausführenden Aufgaben und schließt den Dienst.
* ist terminiert (): Testen Sie, ob alle Aufgaben ausgeführt wurden.
* isShutdown (): Testen Sie, ob der Executorservice geschlossen wurde
!
* Zeitplan (Aufgabe, Initdelay): Planen Sie die eingereichte aufrufbare oder ausgeführte Aufgabe, die nach der von InitDelay angegebenen Zeit ausgeführt werden soll.
* ScheduleatFixedRate (): Planen Sie die eingereichte Runnable -Aufgabe, die wiederholt im angegebenen Intervall ausgeführt werden soll.
* SchedulewithFixedDelay (): Planen Sie die eingereichte ausgeführte Aufgabe, die nach jeder Ausführung wiederholt ausgeführt werden soll. Warten Sie auf die durch Verzögerung angegebene Zeit.
*
* Erhalten Sie verschiedene Dienstobjekte über die Ausführende Klasse.
* Anruf
* NewsingLethreadExecutor: Generiert ein ExecutorService -Objekt, das nur einen Thread enthält, der zur Ausführung von Aufgaben verwendet werden kann.
* NewcachedThreadpool (): Erzeugt ein ExecutorService -Objekt, das einen Thread -Pool enthält.
* NEWFIXED Threadpool (int Poolsize): Erzeugt ein Executorservice -Objekt, das einen Thread -Pool von Poolsize enthält.
* NewsingLethreadScheduledexecutor: Generiert ein enderExecutorService -Objekt. Die Thread -Poolgröße dieses Objekts beträgt 1. Wenn es mehr als eine Aufgabe gibt, werden die Aufgaben nacheinander ausgeführt.
* NewsschonedThreadpool (int PoolSize): Generiert ein planteDexecutorService -Objekt. Die Thread -Pool -Größe dieses Objekts ist poolsize, wenn die Anzahl der Aufgaben größer ist als Poolsize, die Aufgabe wartet auf die Ausführung in einer Warteschlange, die in einer Warteschlange wartet.
*/
öffentliche Klasse Executearch {
/**
* Dieser Thread gibt eine Zeichenfolge aus
*/
öffentliche statische Klasse mythead implementiert runnable {
public void run () {
System.out.println ("Task -Wiederholung" + System.currentTimemillis ());
versuchen {
Thread.sleep (1000);
} catch (InterruptedException e) {
System.out.println ("Aufgabe unterbrochen".
+ System.currentTimemillis ());
}
}
}
/**
* Der Anruf beendet eine andere Aufgabe
*/
öffentliche statische Klasse mykallierbare implementiert Callable {
Private Zukunft;
public mycallable (Future Future) {
this.future = Future;
}
public String call () {
System.out.println ("Aufgabe abbrechen ..."
+ + System.currentTimemillis ());
this.future.cancel (wahr);
Rückgabe "Aufgabe storniert!";
}
}
/**
* @param args
* @Throws ExecutionException
* @Throws InterruptedException
*/
öffentliche statische Leere Main (String [] args) löst InterruptedException aus,
ExecutionException {
// Erzeugen Sie ein Executorservice -Objekt mit einem Thread -Pool, und die Größe des Fadenpools wird nach Bedarf eingestellt.
// Nachdem der Thread die Aufgabe ausgeführt hat, kehrt er zum Thread -Pool zurück, damit die nächste Aufgabe verwendet werden soll.
ExecutorService CachedService = Executors.NewCachedThreadpool ();
Zukünftige MyThreadFuture = zwischengespeichert.
Zukünftige mycallableFuture = zwischengespeichert.
MyThreadfuture));
System.out.println (myCallableFuture.get ());
System.out.println ("-----------------");
// Runnable -Aufgaben in Callable -Aufgaben konvertieren
Callable MyThreadCallable = Executors.Callable (new myThread ());
Zukünftige MyTheadCallableFuture = CachedService.Submit (MyTheadCallable);
// Bei Laufaufgaben wird nach dem Umwandeln in Callable -Aufgaben kein Wert zurückgegeben
System.out.println (MyThreadCallableFuture.get ());
CachedService.Shutdownnow ();
System.out.println ("-----------------");
// Generieren Sie ein Executorservice -Objekt, das einen Thread -Pool von Poolsize enthält.
// Wenn die Anzahl der Aufgaben größer ist als Poolsize, werden die Aufgaben in einer Warteschlange in der Sequenz ausgeführt
ExecutorService FixedService = Executors.NewFixed threadpool (2);
FixedService.Submit (New MyThread ());
FixedService.Submit (New MyThread ());
// Da die Thread -Poolgröße 2 ist, müssen die nachfolgenden Aufgaben darauf warten, dass die vorherigen Aufgaben ausgeführt werden, bevor sie ausgeführt werden können.
MyThreadFuture = FixedService.Submit (new myThread ());
MyCallableFuture = FixedService.Submit (neuer mykallierbar (MyThreadFuture));
System.out.println (myCallableFuture.get ());
fixedService.shutdownnow ();
System.out.println ("-----------------");
// Erstellen Sie ein enderExecutorService -Objekt, die Thread -Poolgröße dieses Objekts ist poolsize.
// Wenn die Anzahl der Aufgaben größer ist als Poolsize, wartet die Aufgabe auf die Ausführung in einer Warteschlange
TeplanedexecutorService festgelegt
.NewScheduledThreadpool (2);
// neue Aufgabe 1 erstellen 1
MyThread Task1 = new MyThread ();
// Verwenden Sie den Aufgabenausführungsdienst, um Aufgabe 1 sofort auszuführen und dann alle 2 Sekunden danach alle 2 Sekunden auszuführen.
MyTheadfuture = FixedScheduledService.ScheduleatFixedrat (Task1, 0, 2,
TimeUnit.seconds);
// neue Aufgabe 2 erstellen 2
Mycallable task2 = new MyCallable (MyThreadfuture);
// Verwenden Sie den Aufgabenausführungsdienst, um 5 Sekunden vor der Ausführung der Aufgabe zu warten. 2. Nach der Ausführung wird Aufgabe 1 geschlossen.
MyCallableFuture = FixedScheduledService.Schedule (Task2, 5,
TimeUnit.seconds);
System.out.println (myCallableFuture.get ());
FixedScheduledService.Shutdownnow ();
}
}